From 68253e14ee3d0e81881bc908b07b5ba141daf226 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 27 Nov 2024 03:20:22 +0000
Subject: [PATCH 01/10] Don't suggest restricting bound with unstable traits on
stable
On nightly, we mention the trait is unstable
```
error[E0277]: the trait bound `T: Unstable` is not satisfied
--> $DIR/unstable-trait-suggestion.rs:13:9
|
LL | foo(t)
| --- ^ the trait `Unstable` is not implemented for `T`
| |
| required by a bound introduced by this call
|
note: required by a bound in `foo`
--> $DIR/unstable-trait-suggestion.rs:9:11
|
LL | fn foo<T: Unstable>(_: T) {}
| ^^^^^^^^ required by this bound in `foo`
help: consider restricting type parameter `T` but it is an `unstable` trait
|
LL | pub fn demo<T: Unstable>(t: T) {
| ++++++++++
```
On stable, we don't suggest the trait at all
```
error[E0277]: the trait bound `T: Unstable` is not satisfied
--> $DIR/unstable-trait-suggestion.rs:13:9
|
LL | foo(t)
| --- ^ the trait `Unstable` is not implemented for `T`
| |
| required by a bound introduced by this call
|
note: required by a bound in `foo`
--> $DIR/unstable-trait-suggestion.rs:9:11
|
LL | fn foo<T: Unstable>(_: T) {}
| ^^^^^^^^ required by this bound in `foo`
```
---
compiler/rustc_middle/src/ty/diagnostics.rs | 32 ++++++++++++++-----
...rust-call-abi-not-a-tuple-ice-81974.stderr | 10 +++---
.../mir/validate/validate-unsize-cast.stderr | 2 +-
.../trait-bounds/unstable-trait-suggestion.rs | 15 +++++++++
.../unstable-trait-suggestion.stderr | 21 ++++++++++++
tests/ui/tuple/builtin-fail.stderr | 2 +-
6 files changed, 67 insertions(+), 15 deletions(-)
create mode 100644 tests/ui/trait-bounds/unstable-trait-suggestion.rs
create mode 100644 tests/ui/trait-bounds/unstable-trait-suggestion.stderr
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index fd807882e0f7c..b08e1632f65aa 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -1,6 +1,5 @@
//! Diagnostics related methods for `Ty`.
-use std::borrow::Cow;
use std::fmt::Write;
use std::ops::ControlFlow;
@@ -278,8 +277,21 @@ pub fn suggest_constraining_type_params<'a>(
span_to_replace: Option<Span>,
) -> bool {
let mut grouped = FxHashMap::default();
+ let mut unstable_suggestion = false;
param_names_and_constraints.for_each(|(param_name, constraint, def_id)| {
- grouped.entry(param_name).or_insert(Vec::new()).push((constraint, def_id))
+ let stable = match def_id {
+ Some(def_id) => match tcx.lookup_stability(def_id) {
+ Some(s) => s.level.is_stable(),
+ None => true,
+ },
+ None => true,
+ };
+ if stable || tcx.sess.is_nightly_build() {
+ grouped.entry(param_name).or_insert(Vec::new()).push((constraint, def_id));
+ if !stable {
+ unstable_suggestion = true;
+ }
+ }
});
let mut applicability = Applicability::MachineApplicable;
@@ -464,28 +476,32 @@ pub fn suggest_constraining_type_params<'a>(
if suggestions.len() == 1 {
let (span, suggestion, msg) = suggestions.pop().unwrap();
+ let post = if unstable_suggestion { " but it is an `unstable` trait" } else { "" };
let msg = match msg {
SuggestChangingConstraintsMessage::RestrictBoundFurther => {
- Cow::from("consider further restricting this bound")
+ format!("consider further restricting this bound{post}")
}
SuggestChangingConstraintsMessage::RestrictType { ty } => {
- Cow::from(format!("consider restricting type parameter `{ty}`"))
+ format!("consider restricting type parameter `{ty}`{post}")
}
SuggestChangingConstraintsMessage::RestrictTypeFurther { ty } => {
- Cow::from(format!("consider further restricting type parameter `{ty}`"))
+ format!("consider further restricting type parameter `{ty}`{post}")
}
SuggestChangingConstraintsMessage::RemoveMaybeUnsized => {
- Cow::from("consider removing the `?Sized` bound to make the type parameter `Sized`")
+ format!(
+ "consider removing the `?Sized` bound to make the type parameter `Sized`{post}"
+ )
}
SuggestChangingConstraintsMessage::ReplaceMaybeUnsizedWithSized => {
- Cow::from("consider replacing `?Sized` with `Sized`")
+ format!("consider replacing `?Sized` with `Sized`{post}")
}
};
err.span_suggestion_verbose(span, msg, suggestion, applicability);
} else if suggestions.len() > 1 {
+ let post = if unstable_suggestion { " but some of them are `unstable` traits" } else { "" };
err.multipart_suggestion_verbose(
- "consider restricting type parameters",
+ format!("consider restricting type parameters{post}"),
suggestions.into_iter().map(|(span, suggestion, _)| (span, suggestion)).collect(),
applicability,
);
diff --git a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
index 206a6801065db..17506dadb9f7b 100644
--- a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
+++ b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
@@ -6,7 +6,7 @@ LL | impl<A, B> FnOnce<A> for CachedFun<A, B>
|
note: required by a bound in `FnOnce`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound but it is an `unstable` trait
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -19,7 +19,7 @@ LL | impl<A, B> FnMut<A> for CachedFun<A, B>
|
note: required by a bound in `FnMut`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound but it is an `unstable` trait
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
LL | extern "rust-call" fn call_once(mut self, a: A) -> Self::Output {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
|
-help: consider further restricting this bound
+help: consider further restricting this bound but it is an `unstable` trait
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -41,7 +41,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
LL | extern "rust-call" fn call_mut(&mut self, a: A) -> Self::Output {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
|
-help: consider further restricting this bound
+help: consider further restricting this bound but it is an `unstable` trait
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -56,7 +56,7 @@ LL | self.call_mut(a)
|
note: required by a bound in `call_mut`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound but it is an `unstable` trait
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
diff --git a/tests/ui/mir/validate/validate-unsize-cast.stderr b/tests/ui/mir/validate/validate-unsize-cast.stderr
index cfb47b34e980b..513e1e597bf57 100644
--- a/tests/ui/mir/validate/validate-unsize-cast.stderr
+++ b/tests/ui/mir/validate/validate-unsize-cast.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `CastTo`
|
LL | pub trait CastTo<U: ?Sized>: Unsize<U> {}
| ^^^^^^^^^ required by this bound in `CastTo`
-help: consider further restricting this bound
+help: consider further restricting this bound but it is an `unstable` trait
|
LL | impl<T: ?Sized + std::marker::Unsize<U>, U: ?Sized> CastTo<U> for T {}
| ++++++++++++++++++++++++
diff --git a/tests/ui/trait-bounds/unstable-trait-suggestion.rs b/tests/ui/trait-bounds/unstable-trait-suggestion.rs
new file mode 100644
index 0000000000000..fff61e4a6f5f1
--- /dev/null
+++ b/tests/ui/trait-bounds/unstable-trait-suggestion.rs
@@ -0,0 +1,15 @@
+#![feature(staged_api)]
+#![allow(internal_features)]
+#![stable(feature = "unit_test", since = "1.0.0")]
+
+#[unstable(feature = "step_trait", issue = "42168")]
+pub trait Unstable {}
+
+#[stable(feature = "unit_test", since = "1.0.0")]
+fn foo<T: Unstable>(_: T) {}
+
+#[stable(feature = "unit_test", since = "1.0.0")]
+pub fn demo<T>(t: T) { //~ HELP consider restricting type parameter `T` but it is an `unstable` trait
+ foo(t) //~ ERROR E0277
+}
+fn main() {}
diff --git a/tests/ui/trait-bounds/unstable-trait-suggestion.stderr b/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
new file mode 100644
index 0000000000000..7b5e9f8d124a7
--- /dev/null
+++ b/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
@@ -0,0 +1,21 @@
+error[E0277]: the trait bound `T: Unstable` is not satisfied
+ --> $DIR/unstable-trait-suggestion.rs:13:9
+ |
+LL | foo(t)
+ | --- ^ the trait `Unstable` is not implemented for `T`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `foo`
+ --> $DIR/unstable-trait-suggestion.rs:9:11
+ |
+LL | fn foo<T: Unstable>(_: T) {}
+ | ^^^^^^^^ required by this bound in `foo`
+help: consider restricting type parameter `T` but it is an `unstable` trait
+ |
+LL | pub fn demo<T: Unstable>(t: T) {
+ | ++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/tuple/builtin-fail.stderr b/tests/ui/tuple/builtin-fail.stderr
index e3e29a73fdc01..cc295dabb1748 100644
--- a/tests/ui/tuple/builtin-fail.stderr
+++ b/tests/ui/tuple/builtin-fail.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `assert_is_tuple`
|
LL | fn assert_is_tuple<T: std::marker::Tuple + ?Sized>() {}
| ^^^^^^^^^^^^^^^^^^ required by this bound in `assert_is_tuple`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` but it is an `unstable` trait
|
LL | fn from_param_env<T: std::marker::Tuple>() {
| ++++++++++++++++++++
From d13c34828e4bc0924f7e27bae994f9afecaf0ab4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Thu, 28 Nov 2024 18:43:28 +0000
Subject: [PATCH 02/10] reword trait bound suggestion message to include the
bounds
---
compiler/rustc_middle/src/ty/diagnostics.rs | 45 +++++++++++++------
tests/rustdoc-ui/issues/issue-96287.stderr | 4 +-
...ns-in-super-trait-bound-unsatisfied.stderr | 4 +-
.../associated-types-no-suitable-bound.stderr | 4 +-
.../defaults-suitability.current.stderr | 4 +-
.../defaults-suitability.next.stderr | 4 +-
.../hr-associated-type-bound-param-6.stderr | 2 +-
.../hr-associated-type-projection-1.stderr | 2 +-
.../issue-27675-unchecked-bounds.stderr | 2 +-
.../issue-43784-associated-type.stderr | 2 +-
tests/ui/associated-types/issue-59324.stderr | 8 ++--
tests/ui/async-await/issue-70818.stderr | 2 +-
tests/ui/async-await/issue-86507.stderr | 2 +-
.../typeck-auto-trait-no-supertraits-2.stderr | 2 +-
tests/ui/binop/binop-consume-args.stderr | 40 ++++++++---------
tests/ui/binop/binop-move-semantics.stderr | 4 +-
tests/ui/binop/issue-93927.stderr | 2 +-
tests/ui/borrowck/clone-on-ref.stderr | 4 +-
...or-suggest-clone-panic-issue-127915.stderr | 2 +-
...builtin-superkinds-double-superkind.stderr | 4 +-
.../builtin-superkinds-in-metadata.stderr | 2 +-
...builtin-superkinds-typaram-not-send.stderr | 2 +-
...ds-cant-promote-superkind-in-struct.stderr | 4 +-
.../ui/closures/closure-bounds-subtype.stderr | 2 +-
tests/ui/closures/issue-67123.stderr | 2 +-
.../fuzzing/best-obligation-ICE.stderr | 2 +-
.../issues/issue-61336-2.stderr | 2 +-
.../const-generics/issues/issue-61336.stderr | 2 +-
.../ct-var-in-collect_all_mismatches.stderr | 2 +-
tests/ui/consts/fn_trait_refs.stderr | 6 +--
.../unstable-const-fn-in-libcore.stderr | 2 +-
.../dropck/explicit-drop-bounds.bad1.stderr | 4 +-
.../dropck/explicit-drop-bounds.bad2.stderr | 4 +-
tests/ui/error-codes/E0229.stderr | 4 +-
.../blame-trait-error.stderr | 30 ++++++-------
.../blame-trait-error-spans-on-exprs.stderr | 28 ++++++------
.../generic-associated-types-where.stderr | 2 +-
.../impl_bounds.stderr | 4 +-
.../issue-68641-check-gat-bounds.stderr | 2 +-
.../issue-68642-broken-llvm-ir.stderr | 2 +-
.../issue-68643-broken-mir.stderr | 2 +-
.../issue-68644-codegen-selection.stderr | 2 +-
.../issue-68645-codegen-fulfillment.stderr | 2 +-
.../issue-68656-unsized-values.stderr | 2 +-
.../issue-74824.current.stderr | 2 +-
.../issue-74824.next.stderr | 2 +-
.../missing-bounds.stderr | 8 ++--
.../structually-relate-aliases.stderr | 2 +-
...igher-ranker-supertraits-transitive.stderr | 2 +-
.../normalize-under-binder/issue-85455.stderr | 4 +-
...-predicate-entailment-error.current.stderr | 10 ++---
tests/ui/impl-trait/issue-55872-1.stderr | 4 +-
.../impl-trait/normalize-tait-in-const.stderr | 2 +-
tests/ui/issues/issue-6738.stderr | 2 +-
.../ui/kindck/kindck-impl-type-params.stderr | 8 ++--
...rust-call-abi-not-a-tuple-ice-81974.stderr | 10 ++---
.../unsatisfied-bounds-type-alias-body.stderr | 2 +-
.../methods/filter-relevant-fn-bounds.stderr | 8 ++--
.../mir/validate/validate-unsize-cast.stderr | 2 +-
.../missing-trait-bound-for-op.stderr | 2 +-
tests/ui/moves/issue-34721.stderr | 2 +-
...use_of_moved_value_copy_suggestions.stderr | 20 ++++-----
tests/ui/phantom-auto-trait.stderr | 4 +-
...-implied-bounds-projection-gap-hr-1.stderr | 4 +-
tests/ui/resolve/issue-55673.stderr | 2 +-
...fault-generic-associated-type-bound.stderr | 2 +-
.../defaultimpl/specialization-wfcheck.stderr | 2 +-
tests/ui/specialization/issue-33017.stderr | 2 +-
.../min_specialization/issue-79224.stderr | 8 ++--
tests/ui/suggestions/assoc-const-as-fn.stderr | 2 +-
tests/ui/suggestions/bound-suggestions.stderr | 12 ++---
.../ui/suggestions/clone-bounds-121524.stderr | 2 +-
...n-unconstrained-borrowed-type-param.stderr | 2 +-
.../ui/suggestions/derive-clone-for-eq.stderr | 2 +-
.../derive-macro-missing-bounds.stderr | 8 ++--
.../issue-106443-sugg-clone-for-bound.stderr | 2 +-
tests/ui/suggestions/issue-97677.stderr | 2 +-
...missing-bound-in-derive-copy-impl-2.stderr | 8 ++--
...missing-bound-in-derive-copy-impl-3.stderr | 8 ++--
.../missing-bound-in-derive-copy-impl.stderr | 16 +++----
...missing-bound-in-manual-copy-impl-2.stderr | 2 +-
.../missing-bound-in-manual-copy-impl.stderr | 2 +-
.../restrict-existing-type-bounds.stderr | 4 +-
.../suggestions/restrict-type-argument.stderr | 12 ++---
.../trait-impl-bound-suggestions.stderr | 8 ++--
...estrict-assoc-type-of-generic-bound.stderr | 2 +-
.../trait-bounds/unstable-trait-suggestion.rs | 2 +-
.../unstable-trait-suggestion.stderr | 2 +-
tests/ui/traits/alias/wf.stderr | 2 +-
.../ui/traits/bad-method-typaram-kind.stderr | 2 +-
.../traits/bound/on-structs-and-enums.stderr | 6 +--
.../call-generic-method-chain.stderr | 2 +-
.../call-generic-method-dup-bound.stderr | 4 +-
.../call-generic-method-fail.stderr | 2 +-
.../call-generic-method-pass.stderr | 2 +-
.../const-closure-trait-method-fail.stderr | 2 +-
.../const-closure-trait-method.stderr | 2 +-
.../traits/const-traits/const-closures.stderr | 6 +--
.../const-traits/trait-where-clause.stderr | 4 +-
.../traits/copy-impl-cannot-normalize.stderr | 2 +-
...py-is-not-modulo-regions.not_static.stderr | 2 +-
.../inductive-overflow/two-traits.stderr | 2 +-
.../repeated-supertrait-ambig.stderr | 4 +-
tests/ui/traits/issue-21837.stderr | 2 +-
tests/ui/traits/issue-43784-supertrait.stderr | 2 +-
.../diagnostics/projection-trait-ref.stderr | 2 +-
.../next-solver/dyn-incompatibility.stderr | 4 +-
.../global-cache-and-parallel-frontend.stderr | 2 +-
.../issue-118950-root-region.stderr | 2 +-
tests/ui/tuple/builtin-fail.stderr | 2 +-
.../bounds-are-checked-2.stderr | 2 +-
.../bounds-are-checked3.stderr | 2 +-
tests/ui/type-alias-impl-trait/future.stderr | 2 +-
.../generic_duplicate_param_use2.stderr | 2 +-
.../generic_duplicate_param_use4.stderr | 2 +-
.../generic_underconstrained.stderr | 4 +-
.../generic_underconstrained2.stderr | 8 ++--
.../type-alias-impl-trait/issue-52843.stderr | 2 +-
.../type-alias-impl-trait/issue-53092.stderr | 2 +-
.../type-alias-impl-trait/issue-89686.stderr | 2 +-
.../issue-90400-1.stderr | 2 +-
.../issue-90400-2.stderr | 2 +-
.../not_well_formed.stderr | 4 +-
.../underconstrained_generic.stderr | 2 +-
.../wf-check-fn-def.stderr | 2 +-
.../wf_check_closures.stderr | 2 +-
...esolved-assoc-ty-suggest-trait.lazy.stderr | 6 +--
tests/ui/type/type-check-defaults.stderr | 2 +-
.../type/type-check/missing_trait_impl.stderr | 8 ++--
.../ui/typeck/bad-index-due-to-nested.stderr | 4 +-
tests/ui/typeck/issue-90164.stderr | 2 +-
...ypeck-default-trait-impl-send-param.stderr | 2 +-
tests/ui/union/issue-81199.stderr | 2 +-
tests/ui/unop/unop-move-semantics.stderr | 2 +-
tests/ui/wf/issue-96810.stderr | 2 +-
tests/ui/wf/wf-enum-bound.stderr | 2 +-
.../wf/wf-enum-fields-struct-variant.stderr | 2 +-
tests/ui/wf/wf-enum-fields.stderr | 2 +-
tests/ui/wf/wf-fn-where-clause.stderr | 2 +-
.../wf/wf-impl-associated-type-trait.stderr | 2 +-
tests/ui/wf/wf-in-fn-arg.stderr | 2 +-
tests/ui/wf/wf-in-fn-ret.stderr | 2 +-
tests/ui/wf/wf-in-fn-type-arg.stderr | 2 +-
tests/ui/wf/wf-in-fn-type-ret.stderr | 2 +-
tests/ui/wf/wf-in-fn-where-clause.stderr | 2 +-
tests/ui/wf/wf-in-obj-type-trait.stderr | 2 +-
...f-inherent-impl-method-where-clause.stderr | 2 +-
.../wf/wf-inherent-impl-where-clause.stderr | 2 +-
tests/ui/wf/wf-struct-bound.stderr | 2 +-
tests/ui/wf/wf-struct-field.stderr | 2 +-
.../wf/wf-trait-associated-type-bound.stderr | 2 +-
tests/ui/wf/wf-trait-bound.stderr | 2 +-
tests/ui/wf/wf-trait-superbound.stderr | 2 +-
...traints-are-local-for-inherent-impl.stderr | 2 +-
...onstraints-are-local-for-trait-impl.stderr | 2 +-
155 files changed, 331 insertions(+), 314 deletions(-)
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index b08e1632f65aa..a8500398082fb 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -171,7 +171,7 @@ enum SuggestChangingConstraintsMessage<'a> {
fn suggest_changing_unsized_bound(
generics: &hir::Generics<'_>,
- suggestions: &mut Vec<(Span, String, SuggestChangingConstraintsMessage<'_>)>,
+ suggestions: &mut Vec<(Span, String, String, SuggestChangingConstraintsMessage<'_>)>,
param: &hir::GenericParam<'_>,
def_id: Option<DefId>,
) {
@@ -206,7 +206,8 @@ fn suggest_changing_unsized_bound(
continue;
}
- let mut push_suggestion = |sp, msg| suggestions.push((sp, String::new(), msg));
+ let mut push_suggestion =
+ |sp, msg| suggestions.push((sp, "Sized".to_string(), String::new(), msg));
if predicate.bounds.len() == unsized_bounds.len() {
// All the bounds are unsized bounds, e.g.
@@ -348,10 +349,20 @@ pub fn suggest_constraining_type_params<'a>(
use SuggestChangingConstraintsMessage::RestrictBoundFurther;
if let Some(open_paren_sp) = open_paren_sp {
- suggestions.push((open_paren_sp, "(".to_string(), RestrictBoundFurther));
- suggestions.push((span, format!("){suggestion}"), RestrictBoundFurther));
+ suggestions.push((
+ open_paren_sp,
+ constraint.clone(),
+ "(".to_string(),
+ RestrictBoundFurther,
+ ));
+ suggestions.push((
+ span,
+ constraint.clone(),
+ format!("){suggestion}"),
+ RestrictBoundFurther,
+ ));
} else {
- suggestions.push((span, suggestion, RestrictBoundFurther));
+ suggestions.push((span, constraint.clone(), suggestion, RestrictBoundFurther));
}
};
@@ -409,6 +420,7 @@ pub fn suggest_constraining_type_params<'a>(
// - insert: `, X: Bar`
suggestions.push((
generics.tail_span_for_predicate_suggestion(),
+ constraint.clone(),
constraints.iter().fold(String::new(), |mut string, &(constraint, _)| {
write!(string, ", {param_name}: {constraint}").unwrap();
string
@@ -438,6 +450,7 @@ pub fn suggest_constraining_type_params<'a>(
// default (`<T=Foo>`), so we suggest adding `where T: Bar`.
suggestions.push((
generics.tail_span_for_predicate_suggestion(),
+ constraint.clone(),
format!("{where_prefix} {param_name}: {constraint}"),
SuggestChangingConstraintsMessage::RestrictTypeFurther { ty: param_name },
));
@@ -451,6 +464,7 @@ pub fn suggest_constraining_type_params<'a>(
if let Some(colon_span) = param.colon_span {
suggestions.push((
colon_span.shrink_to_hi(),
+ constraint.clone(),
format!(" {constraint}"),
SuggestChangingConstraintsMessage::RestrictType { ty: param_name },
));
@@ -463,6 +477,7 @@ pub fn suggest_constraining_type_params<'a>(
// - help: consider restricting this type parameter with `T: Foo`
suggestions.push((
param.span.shrink_to_hi(),
+ constraint.clone(),
format!(": {constraint}"),
SuggestChangingConstraintsMessage::RestrictType { ty: param_name },
));
@@ -471,12 +486,16 @@ pub fn suggest_constraining_type_params<'a>(
// FIXME: remove the suggestions that are from derive, as the span is not correct
suggestions = suggestions
.into_iter()
- .filter(|(span, _, _)| !span.in_derive_expansion())
+ .filter(|(span, _, _, _)| !span.in_derive_expansion())
.collect::<Vec<_>>();
if suggestions.len() == 1 {
- let (span, suggestion, msg) = suggestions.pop().unwrap();
- let post = if unstable_suggestion { " but it is an `unstable` trait" } else { "" };
+ let (span, constraint, suggestion, msg) = suggestions.pop().unwrap();
+ let post = format!(
+ " with {}trait{} `{constraint}`",
+ if unstable_suggestion { "unstable " } else { "" },
+ if constraint.contains('+') { "s" } else { "" },
+ );
let msg = match msg {
SuggestChangingConstraintsMessage::RestrictBoundFurther => {
format!("consider further restricting this bound{post}")
@@ -488,21 +507,19 @@ pub fn suggest_constraining_type_params<'a>(
format!("consider further restricting type parameter `{ty}`{post}")
}
SuggestChangingConstraintsMessage::RemoveMaybeUnsized => {
- format!(
- "consider removing the `?Sized` bound to make the type parameter `Sized`{post}"
- )
+ format!("consider removing the `?Sized` bound to make the type parameter `Sized`")
}
SuggestChangingConstraintsMessage::ReplaceMaybeUnsizedWithSized => {
- format!("consider replacing `?Sized` with `Sized`{post}")
+ format!("consider replacing `?Sized` with `Sized`")
}
};
err.span_suggestion_verbose(span, msg, suggestion, applicability);
} else if suggestions.len() > 1 {
- let post = if unstable_suggestion { " but some of them are `unstable` traits" } else { "" };
+ let post = if unstable_suggestion { " (some of them are unstable traits)" } else { "" };
err.multipart_suggestion_verbose(
format!("consider restricting type parameters{post}"),
- suggestions.into_iter().map(|(span, suggestion, _)| (span, suggestion)).collect(),
+ suggestions.into_iter().map(|(span, _, suggestion, _)| (span, suggestion)).collect(),
applicability,
);
}
diff --git a/tests/rustdoc-ui/issues/issue-96287.stderr b/tests/rustdoc-ui/issues/issue-96287.stderr
index 9aba033216484..40dc1cc0e704b 100644
--- a/tests/rustdoc-ui/issues/issue-96287.stderr
+++ b/tests/rustdoc-ui/issues/issue-96287.stderr
@@ -4,7 +4,7 @@ error[E0220]: associated type `Assoc` not found for `V`
LL | pub type Foo<V> = impl Trait<V::Assoc>;
| ^^^^^ there is an associated type `Assoc` in the trait `TraitWithAssoc`
|
-help: consider restricting type parameter `V`
+help: consider restricting type parameter `V` with trait `TraitWithAssoc`
|
LL | pub type Foo<V: TraitWithAssoc> = impl Trait<V::Assoc>;
| ++++++++++++++++
@@ -16,7 +16,7 @@ LL | pub type Foo<V> = impl Trait<V::Assoc>;
| ^^^^^ there is an associated type `Assoc` in the trait `TraitWithAssoc`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider restricting type parameter `V`
+help: consider restricting type parameter `V` with trait `TraitWithAssoc`
|
LL | pub type Foo<V: TraitWithAssoc> = impl Trait<V::Assoc>;
| ++++++++++++++++
diff --git a/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr b/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
index d87e769b50538..4044e124c8be1 100644
--- a/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
+++ b/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `C: Bar<5>` is not satisfied
LL | pub struct Structure<C: Tec> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bar<5>` is not implemented for `C`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Bar<5>`
|
LL | pub struct Structure<C: Tec + Bar<5>> {
| ++++++++
@@ -15,7 +15,7 @@ error[E0277]: the trait bound `C: Bar<5>` is not satisfied
LL | _field: C::BarType,
| ^^^^^^^^^^ the trait `Bar<5>` is not implemented for `C`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Bar<5>`
|
LL | pub struct Structure<C: Tec + Bar<5>> {
| ++++++++
diff --git a/tests/ui/associated-types/associated-types-no-suitable-bound.stderr b/tests/ui/associated-types/associated-types-no-suitable-bound.stderr
index 9713051d97327..4f951ee4b4e62 100644
--- a/tests/ui/associated-types/associated-types-no-suitable-bound.stderr
+++ b/tests/ui/associated-types/associated-types-no-suitable-bound.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `T: Get` is not satisfied
LL | fn uhoh<T>(foo: <T as Get>::Value) {}
| ^^^^^^^^^^^^^^^^^ the trait `Get` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Get`
|
LL | fn uhoh<T: Get>(foo: <T as Get>::Value) {}
| +++++
@@ -15,7 +15,7 @@ error[E0277]: the trait bound `T: Get` is not satisfied
LL | fn uhoh<T>(foo: <T as Get>::Value) {}
| ^^ the trait `Get` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Get`
|
LL | fn uhoh<T: Get>(foo: <T as Get>::Value) {}
| +++++
diff --git a/tests/ui/associated-types/defaults-suitability.current.stderr b/tests/ui/associated-types/defaults-suitability.current.stderr
index 9c0ae59ae43bf..c98ffde25fbac 100644
--- a/tests/ui/associated-types/defaults-suitability.current.stderr
+++ b/tests/ui/associated-types/defaults-suitability.current.stderr
@@ -47,7 +47,7 @@ note: required by a bound in `Foo::Bar`
|
LL | type Bar: Clone = Vec<T>;
| ^^^^^ required by this bound in `Foo::Bar`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::clone::Clone`
|
LL | trait Foo<T: std::clone::Clone> {
| +++++++++++++++++++
@@ -132,7 +132,7 @@ LL | Self::Baz: Clone,
...
LL | type Baz = T;
| --- required by a bound in this associated type
-help: consider further restricting type parameter `T`
+help: consider further restricting type parameter `T` with trait `std::clone::Clone`
|
LL | Self::Baz: Clone, T: std::clone::Clone
| ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/tests/ui/associated-types/defaults-suitability.next.stderr b/tests/ui/associated-types/defaults-suitability.next.stderr
index 9c0ae59ae43bf..c98ffde25fbac 100644
--- a/tests/ui/associated-types/defaults-suitability.next.stderr
+++ b/tests/ui/associated-types/defaults-suitability.next.stderr
@@ -47,7 +47,7 @@ note: required by a bound in `Foo::Bar`
|
LL | type Bar: Clone = Vec<T>;
| ^^^^^ required by this bound in `Foo::Bar`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::clone::Clone`
|
LL | trait Foo<T: std::clone::Clone> {
| +++++++++++++++++++
@@ -132,7 +132,7 @@ LL | Self::Baz: Clone,
...
LL | type Baz = T;
| --- required by a bound in this associated type
-help: consider further restricting type parameter `T`
+help: consider further restricting type parameter `T` with trait `std::clone::Clone`
|
LL | Self::Baz: Clone, T: std::clone::Clone
| ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr b/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
index 5278bdb7a5cf2..9d7e0bfee91d1 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `for<'b> T: X<'b, T>` is not satisfied
LL | impl<S, T> X<'_, T> for (S,) {
| ^^^^^^^^ the trait `for<'b> X<'b, T>` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `for<'b> X<'b, T>`
|
LL | impl<S, T: for<'b> X<'b, T>> X<'_, T> for (S,) {
| ++++++++++++++++++
diff --git a/tests/ui/associated-types/hr-associated-type-projection-1.stderr b/tests/ui/associated-types/hr-associated-type-projection-1.stderr
index b871bb51ae313..65ee3236afdec 100644
--- a/tests/ui/associated-types/hr-associated-type-projection-1.stderr
+++ b/tests/ui/associated-types/hr-associated-type-projection-1.stderr
@@ -16,7 +16,7 @@ LL | trait UnsafeCopy<'a, T: Copy>
LL | where
LL | for<'b> <Self as UnsafeCopy<'b, T>>::Item: std::ops::Deref<Target = T>,
| ^^^^^^^^^^ required by this bound in `UnsafeCopy`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `<Target = T>`
|
LL | impl<T: Copy + std::ops::Deref<Target = T>> UnsafeCopy<'_, T> for T {
| ++++++++++++
diff --git a/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr b/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
index 70bf90150b8fa..83afa02397bac 100644
--- a/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
+++ b/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `copy`
|
LL | fn copy<U: Setup + ?Sized>(from: &U::From) -> U::From {
| ^^^^^ required by this bound in `copy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
| +++++++++++++++++++
diff --git a/tests/ui/associated-types/issue-43784-associated-type.stderr b/tests/ui/associated-types/issue-43784-associated-type.stderr
index 529fc1f119a9c..3c91143e90aa8 100644
--- a/tests/ui/associated-types/issue-43784-associated-type.stderr
+++ b/tests/ui/associated-types/issue-43784-associated-type.stderr
@@ -14,7 +14,7 @@ note: required by a bound in `Complete::Assoc`
|
LL | type Assoc: Partial<Self>;
| ^^^^^^^^^^^^^ required by this bound in `Complete::Assoc`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> Complete for T {
| +++++++++++++++++++
diff --git a/tests/ui/associated-types/issue-59324.stderr b/tests/ui/associated-types/issue-59324.stderr
index 6c77ee6044f16..e8693135913ad 100644
--- a/tests/ui/associated-types/issue-59324.stderr
+++ b/tests/ui/associated-types/issue-59324.stderr
@@ -7,7 +7,7 @@ LL | |
LL | | Service<AssocType = <Bug as Foo>::OnlyFoo>
| |______________________________________________^ the trait `Foo` is not implemented for `Bug`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Foo`
|
LL | pub trait ThriftService<Bug: NotFoo + Foo>:
| +++++
@@ -24,7 +24,7 @@ LL | |
LL | | }
| |_^ the trait `Foo` is not implemented for `Bug`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Foo`
|
LL | pub trait ThriftService<Bug: NotFoo + Foo>:
| +++++
@@ -38,7 +38,7 @@ LL | | &self,
LL | | ) -> Self::AssocType;
| |_________________________^ the trait `Foo` is not implemented for `Bug`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Foo`
|
LL | pub trait ThriftService<Bug: NotFoo + Foo>:
| +++++
@@ -61,7 +61,7 @@ error[E0277]: the trait bound `Bug: Foo` is not satisfied
LL | ) -> Self::AssocType;
| ^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `Bug`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Foo`
|
LL | pub trait ThriftService<Bug: NotFoo + Foo>:
| +++++
diff --git a/tests/ui/async-await/issue-70818.stderr b/tests/ui/async-await/issue-70818.stderr
index 317c04d2c7478..654ab42d24f7c 100644
--- a/tests/ui/async-await/issue-70818.stderr
+++ b/tests/ui/async-await/issue-70818.stderr
@@ -9,7 +9,7 @@ note: captured value is not `Send`
|
LL | async { (ty, ty1) }
| ^^^ has type `U` which is not `Send`
-help: consider restricting type parameter `U`
+help: consider restricting type parameter `U` with trait `std::marker::Send`
|
LL | fn foo<T: Send, U: std::marker::Send>(ty: T, ty1: U) -> impl Future<Output = (T, U)> + Send {
| +++++++++++++++++++
diff --git a/tests/ui/async-await/issue-86507.stderr b/tests/ui/async-await/issue-86507.stderr
index f4cd7c42706c8..be0c656339143 100644
--- a/tests/ui/async-await/issue-86507.stderr
+++ b/tests/ui/async-await/issue-86507.stderr
@@ -14,7 +14,7 @@ note: captured value is not `Send` because `&` references cannot be sent unless
LL | let x = x;
| ^ has type `&T` which is not `Send`, because `T` is not `Sync`
= note: required for the cast from `Pin<Box<{async block@$DIR/issue-86507.rs:18:17: 18:27}>>` to `Pin<Box<(dyn Future<Output = ()> + Send + 'async_trait)>>`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Sync`
|
LL | fn bar<'me, 'async_trait, T: Send + std::marker::Sync>(x: &'me T)
| +++++++++++++++++++
diff --git a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
index 4c1de72798c45..1c73bd26267a1 100644
--- a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
+++ b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
@@ -30,7 +30,7 @@ LL | fn copy<T: Magic>(x: T) -> (T, T) { (x, x) }
| ^ - you could clone this value
| |
| consider constraining this type parameter with `Clone`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn copy<T: Magic + Copy>(x: T) -> (T, T) { (x, x) }
| ++++++
diff --git a/tests/ui/binop/binop-consume-args.stderr b/tests/ui/binop/binop-consume-args.stderr
index 1b59216b3c76c..7b0789547831e 100644
--- a/tests/ui/binop/binop-consume-args.stderr
+++ b/tests/ui/binop/binop-consume-args.stderr
@@ -17,7 +17,7 @@ LL | lhs + rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn add<A: Add<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -40,7 +40,7 @@ LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs + rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn add<A: Add<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -64,7 +64,7 @@ LL | lhs - rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn sub<A: Sub<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -87,7 +87,7 @@ LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs - rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn sub<A: Sub<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -111,7 +111,7 @@ LL | lhs * rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn mul<A: Mul<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -134,7 +134,7 @@ LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs * rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn mul<A: Mul<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -158,7 +158,7 @@ LL | lhs / rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn div<A: Div<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -181,7 +181,7 @@ LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs / rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn div<A: Div<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -205,7 +205,7 @@ LL | lhs % rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn rem<A: Rem<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -228,7 +228,7 @@ LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs % rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn rem<A: Rem<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -252,7 +252,7 @@ LL | lhs & rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn bitand<A: BitAnd<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -275,7 +275,7 @@ LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs & rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn bitand<A: BitAnd<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -299,7 +299,7 @@ LL | lhs | rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn bitor<A: BitOr<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -322,7 +322,7 @@ LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs | rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn bitor<A: BitOr<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -346,7 +346,7 @@ LL | lhs ^ rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn bitxor<A: BitXor<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -369,7 +369,7 @@ LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs ^ rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn bitxor<A: BitXor<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -393,7 +393,7 @@ LL | lhs << rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn shl<A: Shl<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -416,7 +416,7 @@ LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs << rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn shl<A: Shl<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
@@ -440,7 +440,7 @@ LL | lhs >> rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn shr<A: Shr<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -463,7 +463,7 @@ LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
| ^ consider constraining this type parameter with `Clone`
LL | lhs >> rhs;
| --- you could clone this value
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Copy`
|
LL | fn shr<A: Shr<B, Output=()>, B: Copy>(lhs: A, rhs: B) {
| ++++++
diff --git a/tests/ui/binop/binop-move-semantics.stderr b/tests/ui/binop/binop-move-semantics.stderr
index 45c7f11040616..e83cc652fff68 100644
--- a/tests/ui/binop/binop-move-semantics.stderr
+++ b/tests/ui/binop/binop-move-semantics.stderr
@@ -20,7 +20,7 @@ LL | x
| - you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn double_move<T: Add<Output=()> + Copy>(x: T) {
| ++++++
@@ -40,7 +40,7 @@ help: consider cloning the value if the performance cost is acceptable
|
LL | x.clone()
| ++++++++
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn move_then_borrow<T: Add<Output=()> + Clone + Copy>(x: T) {
| ++++++
diff --git a/tests/ui/binop/issue-93927.stderr b/tests/ui/binop/issue-93927.stderr
index 9bcf2b17357eb..f8b1a2d84bcbe 100644
--- a/tests/ui/binop/issue-93927.stderr
+++ b/tests/ui/binop/issue-93927.stderr
@@ -6,7 +6,7 @@ LL | val == val
| |
| MyType<T>
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::cmp::Eq`
|
LL | fn cond<T: PartialEq + std::cmp::Eq>(val: MyType<T>) -> bool {
| ++++++++++++++
diff --git a/tests/ui/borrowck/clone-on-ref.stderr b/tests/ui/borrowck/clone-on-ref.stderr
index d5d21296a3f96..361724220a354 100644
--- a/tests/ui/borrowck/clone-on-ref.stderr
+++ b/tests/ui/borrowck/clone-on-ref.stderr
@@ -12,7 +12,7 @@ LL |
LL | drop(cloned_items);
| ------------ immutable borrow later used here
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Clone`
|
LL | fn foo<T: Default + Clone>(list: &mut Vec<T>) {
| +++++++
@@ -39,7 +39,7 @@ LL | fn bar<T: std::fmt::Display>(x: T) {
| ^ consider constraining this type parameter with `Clone`
LL | let a = &x;
| - you could clone this value
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Clone`
|
LL | fn bar<T: std::fmt::Display + Clone>(x: T) {
| +++++++
diff --git a/tests/ui/borrowck/move-error-suggest-clone-panic-issue-127915.stderr b/tests/ui/borrowck/move-error-suggest-clone-panic-issue-127915.stderr
index 6997710ec89fa..e32a0c54dfee8 100644
--- a/tests/ui/borrowck/move-error-suggest-clone-panic-issue-127915.stderr
+++ b/tests/ui/borrowck/move-error-suggest-clone-panic-issue-127915.stderr
@@ -15,7 +15,7 @@ LL | fn test<T, U>(a: i64, b: i64, c: i64, d: i64, e: i64, f: T, g: U) -> i64 {
...
LL | 6, a as f64, b, b as f64, f, c as f64, d, d as f64, e, e as f64, f, g,
| - you could clone this value
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn test<T: Copy, U>(a: i64, b: i64, c: i64, d: i64, e: i64, f: T, g: U) -> i64 {
| ++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
index 592aa4369ce0d..968ac25f60035 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send+Sync { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | impl <T: Sync+'static + std::marker::Send> Foo for (T,) { }
| +++++++++++++++++++
@@ -27,7 +27,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send+Sync { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Sync`
|
LL | impl <T: Send + std::marker::Sync> Foo for (T,T) { }
| +++++++++++++++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
index 251651df4f908..325f11d702701 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
@@ -14,7 +14,7 @@ note: required by a bound in `RequiresRequiresShareAndSend`
|
LL | pub trait RequiresRequiresShareAndSend : RequiresShare + Send { }
| ^^^^ required by this bound in `RequiresRequiresShareAndSend`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | impl <T:Sync+'static + std::marker::Send> RequiresRequiresShareAndSend for X<T> { }
| +++++++++++++++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
index 4a25c42b5835d..5847233a3120b 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | impl <T: Sync+'static + std::marker::Send> Foo for T { }
| +++++++++++++++++++
diff --git a/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr b/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
index 8157590bd9e8e..13cb074591220 100644
--- a/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
+++ b/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `X`
|
LL | struct X<F> where F: FnOnce() + 'static + Send {
| ^^^^ required by this bound in `X`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + std::marker::Send {
| +++++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound in `X`
|
LL | struct X<F> where F: FnOnce() + 'static + Send {
| ^^^^ required by this bound in `X`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + std::marker::Send {
| +++++++++++++++++++
diff --git a/tests/ui/closures/closure-bounds-subtype.stderr b/tests/ui/closures/closure-bounds-subtype.stderr
index 42588668e8a03..73ecd2ef70afa 100644
--- a/tests/ui/closures/closure-bounds-subtype.stderr
+++ b/tests/ui/closures/closure-bounds-subtype.stderr
@@ -15,7 +15,7 @@ help: use parentheses to call this type parameter
|
LL | take_const_owned(f());
| ++
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Sync`
|
LL | fn give_owned<F>(f: F) where F: FnOnce() + Send + std::marker::Sync {
| +++++++++++++++++++
diff --git a/tests/ui/closures/issue-67123.stderr b/tests/ui/closures/issue-67123.stderr
index bdafeaef15fd5..7db82845ea5a6 100644
--- a/tests/ui/closures/issue-67123.stderr
+++ b/tests/ui/closures/issue-67123.stderr
@@ -7,7 +7,7 @@ LL | || { t; t; };
| value moved here
|
= note: move occurs because `t` has type `T`, which does not implement the `Copy` trait
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn foo<T: Copy>(t: T) {
| ++++++
diff --git a/tests/ui/coherence/fuzzing/best-obligation-ICE.stderr b/tests/ui/coherence/fuzzing/best-obligation-ICE.stderr
index 88de8023f6d79..01b6eaf422ed9 100644
--- a/tests/ui/coherence/fuzzing/best-obligation-ICE.stderr
+++ b/tests/ui/coherence/fuzzing/best-obligation-ICE.stderr
@@ -41,7 +41,7 @@ note: required by a bound in `W`
|
LL | struct W<T: Trait>(*mut T);
| ^^^^^ required by this bound in `W`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | impl<T: Trait> Trait for W<W<W<T>>> {}
| +++++++
diff --git a/tests/ui/const-generics/issues/issue-61336-2.stderr b/tests/ui/const-generics/issues/issue-61336-2.stderr
index b0864689f7400..e89e936c4cfa1 100644
--- a/tests/ui/const-generics/issues/issue-61336-2.stderr
+++ b/tests/ui/const-generics/issues/issue-61336-2.stderr
@@ -7,7 +7,7 @@ LL | [x; { N }]
= note: the `Copy` trait is required because this value will be copied for each element of the array
= help: consider using `core::array::from_fn` to initialize the array
= help: see https://doc.rust-lang.org/stable/std/array/fn.from_fn.html for more information
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
| +++++++++++++++++++
diff --git a/tests/ui/const-generics/issues/issue-61336.stderr b/tests/ui/const-generics/issues/issue-61336.stderr
index 111afbda343f7..a1ab680c3895a 100644
--- a/tests/ui/const-generics/issues/issue-61336.stderr
+++ b/tests/ui/const-generics/issues/issue-61336.stderr
@@ -7,7 +7,7 @@ LL | [x; N]
= note: the `Copy` trait is required because this value will be copied for each element of the array
= help: consider using `core::array::from_fn` to initialize the array
= help: see https://doc.rust-lang.org/stable/std/array/fn.from_fn.html for more information
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
| +++++++++++++++++++
diff --git a/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr b/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
index 24572040b9104..33e6b2959ff3f 100644
--- a/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
+++ b/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
@@ -12,7 +12,7 @@ LL | fn unsatisfied(self)
LL | where
LL | T: Bar<N>,
| ^^^^^^ required by this bound in `Foo::<T, N>::unsatisfied`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Bar<N>`
|
LL | impl<T: Bar<N>, const N: usize> Foo<T, N> {
| ++++++++
diff --git a/tests/ui/consts/fn_trait_refs.stderr b/tests/ui/consts/fn_trait_refs.stderr
index 11e13c3efdd19..5ccfb3911fd7b 100644
--- a/tests/ui/consts/fn_trait_refs.stderr
+++ b/tests/ui/consts/fn_trait_refs.stderr
@@ -212,7 +212,7 @@ LL | f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const Fn()`
|
LL | T: ~const Fn<()> + ~const Destruct + ~const Fn(),
| +++++++++++++
@@ -224,7 +224,7 @@ LL | f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const FnMut()`
|
LL | T: ~const FnMut<()> + ~const Destruct + ~const FnMut(),
| ++++++++++++++++
@@ -236,7 +236,7 @@ LL | f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const FnOnce()`
|
LL | T: ~const FnOnce<()> + ~const FnOnce(),
| +++++++++++++++++
diff --git a/tests/ui/consts/unstable-const-fn-in-libcore.stderr b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
index 2bdec1bf41b72..6f7b75caff0db 100644
--- a/tests/ui/consts/unstable-const-fn-in-libcore.stderr
+++ b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
@@ -19,7 +19,7 @@ LL | Opt::None => f(),
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const FnOnce()`
|
LL | const fn unwrap_or_else<F: ~const FnOnce() -> T + ~const FnOnce()>(self, f: F) -> T {
| +++++++++++++++++
diff --git a/tests/ui/dropck/explicit-drop-bounds.bad1.stderr b/tests/ui/dropck/explicit-drop-bounds.bad1.stderr
index 3ef11e2c0bbd1..bbfa858a18390 100644
--- a/tests/ui/dropck/explicit-drop-bounds.bad1.stderr
+++ b/tests/ui/dropck/explicit-drop-bounds.bad1.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `DropMe`
|
LL | struct DropMe<T: Copy>(T);
| ^^^^ required by this bound in `DropMe`
-help: consider further restricting type parameter `T`
+help: consider further restricting type parameter `T` with trait `std::marker::Copy`
|
LL | [T; 1]: Copy, T: std::marker::Copy // But `[T; 1]: Copy` does not imply `T: Copy`
| ~~~~~~~~~~~~~~~~~~~~~~
@@ -25,7 +25,7 @@ note: required by a bound in `DropMe`
|
LL | struct DropMe<T: Copy>(T);
| ^^^^ required by this bound in `DropMe`
-help: consider further restricting type parameter `T`
+help: consider further restricting type parameter `T` with trait `std::marker::Copy`
|
LL | [T; 1]: Copy, T: std::marker::Copy // But `[T; 1]: Copy` does not imply `T: Copy`
| ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/tests/ui/dropck/explicit-drop-bounds.bad2.stderr b/tests/ui/dropck/explicit-drop-bounds.bad2.stderr
index 8138b86ddea46..8d8da4d6c33bb 100644
--- a/tests/ui/dropck/explicit-drop-bounds.bad2.stderr
+++ b/tests/ui/dropck/explicit-drop-bounds.bad2.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `DropMe`
|
LL | struct DropMe<T: Copy>(T);
| ^^^^ required by this bound in `DropMe`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> Drop for DropMe<T>
| +++++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound in `DropMe`
|
LL | struct DropMe<T: Copy>(T);
| ^^^^ required by this bound in `DropMe`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> Drop for DropMe<T>
| +++++++++++++++++++
diff --git a/tests/ui/error-codes/E0229.stderr b/tests/ui/error-codes/E0229.stderr
index 038f44e8b14f0..ab2536cc0c9d5 100644
--- a/tests/ui/error-codes/E0229.stderr
+++ b/tests/ui/error-codes/E0229.stderr
@@ -42,7 +42,7 @@ error[E0277]: the trait bound `I: Foo` is not satisfied
LL | fn baz<I>(x: &<I as Foo<A = Bar>>::A) {}
| ^^^^^^^^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `I`
|
-help: consider restricting type parameter `I`
+help: consider restricting type parameter `I` with trait `Foo`
|
LL | fn baz<I: Foo>(x: &<I as Foo<A = Bar>>::A) {}
| +++++
@@ -53,7 +53,7 @@ error[E0277]: the trait bound `I: Foo` is not satisfied
LL | fn baz<I>(x: &<I as Foo<A = Bar>>::A) {}
| ^^ the trait `Foo` is not implemented for `I`
|
-help: consider restricting type parameter `I`
+help: consider restricting type parameter `I` with trait `Foo`
|
LL | fn baz<I: Foo>(x: &<I as Foo<A = Bar>>::A) {}
| +++++
diff --git a/tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr b/tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr
index 9228a047e8785..5148cc272fdec 100644
--- a/tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr
+++ b/tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr
@@ -25,7 +25,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -73,7 +73,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `std::iter::Iterator`
|
LL | fn example<Q: std::iter::Iterator>(q: Q) {
| +++++++++++++++++++++
@@ -100,7 +100,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `std::iter::Iterator`
|
LL | fn example<Q: std::iter::Iterator>(q: Q) {
| +++++++++++++++++++++
@@ -125,7 +125,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -150,7 +150,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -175,7 +175,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -200,7 +200,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -225,7 +225,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -248,7 +248,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -273,7 +273,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -296,7 +296,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -319,7 +319,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -342,7 +342,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -367,7 +367,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -392,7 +392,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
diff --git a/tests/ui/errors/traits/blame-trait-error-spans-on-exprs.stderr b/tests/ui/errors/traits/blame-trait-error-spans-on-exprs.stderr
index b6a24e12bcc76..90380091c5096 100644
--- a/tests/ui/errors/traits/blame-trait-error-spans-on-exprs.stderr
+++ b/tests/ui/errors/traits/blame-trait-error-spans-on-exprs.stderr
@@ -23,7 +23,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -53,7 +53,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -85,7 +85,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -117,7 +117,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -147,7 +147,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -172,7 +172,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T2`
|
LL | fn example<Q: T2>(q: Q) {
| ++++
@@ -204,7 +204,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -236,7 +236,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -261,7 +261,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T1`
|
LL | fn example<Q: T1>(q: Q) {
| ++++
@@ -286,7 +286,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T1`
|
LL | fn example<Q: T1>(q: Q) {
| ++++
@@ -318,7 +318,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
@@ -343,7 +343,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T1`
|
LL | fn example<Q: T1>(q: Q) {
| ++++
@@ -370,7 +370,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T1`
|
LL | fn example<Q: T1>(q: Q) {
| ++++
@@ -402,7 +402,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q`
+help: consider restricting type parameter `Q` with trait `T3`
|
LL | fn example<Q: T3>(q: Q) {
| ++++
diff --git a/tests/ui/generic-associated-types/generic-associated-types-where.stderr b/tests/ui/generic-associated-types/generic-associated-types-where.stderr
index 9a745c099c0ed..ccb2dd4078414 100644
--- a/tests/ui/generic-associated-types/generic-associated-types-where.stderr
+++ b/tests/ui/generic-associated-types/generic-associated-types-where.stderr
@@ -5,7 +5,7 @@ LL | type Assoc2<T> = Vec<T>;
| ^^^^^^ `T` cannot be formatted with the default formatter
|
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::fmt::Display`
|
LL | type Assoc2<T: std::fmt::Display> = Vec<T>;
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/impl_bounds.stderr b/tests/ui/generic-associated-types/impl_bounds.stderr
index 261070d1db4bf..cb78a5b646f4d 100644
--- a/tests/ui/generic-associated-types/impl_bounds.stderr
+++ b/tests/ui/generic-associated-types/impl_bounds.stderr
@@ -41,7 +41,7 @@ LL | trait Foo {
LL | type C where Self: Clone;
| ^ this trait's associated type doesn't have the requirement `Fooy<T>: Copy`
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> Foo for Fooy<T> {
| +++++++++++++++++++
@@ -66,7 +66,7 @@ LL | trait Foo {
LL | fn d() where Self: Clone;
| ^ this trait's method doesn't have the requirement `Fooy<T>: Copy`
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> Foo for Fooy<T> {
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr b/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
index 55901cf450b67..cdb35b9859702 100644
--- a/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
+++ b/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `UnsafeCopy::Item`
|
LL | type Item<'a>: Copy;
| ^^^^ required by this bound in `UnsafeCopy::Item`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> UnsafeCopy for T {
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr b/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
index 3929e66a25a3a..575bc8bc3e7da 100644
--- a/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
+++ b/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Fun::F`
|
LL | type F<'a>: Fn() -> u32;
| ^^^^^^^^^^^ required by this bound in `Fun::F`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Fn()`
|
LL | impl<T: Fn()> Fun for T {
| ++++++
diff --git a/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr b/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
index 662726b899351..0aaeee510d91d 100644
--- a/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
+++ b/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Fun::F`
|
LL | type F<'a>: Fn() -> u32;
| ^^^^^^^^^^^ required by this bound in `Fun::F`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Fn()`
|
LL | impl<T: Fn()> Fun for T {
| ++++++
diff --git a/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr b/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
index 34278249e35d1..ccc20f8a14a9e 100644
--- a/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
+++ b/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Fun::F`
|
LL | type F<'a>: Fn() -> u32;
| ^^^^^^^^^^^ required by this bound in `Fun::F`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Fn()`
|
LL | impl<T: Fn()> Fun for T {
| ++++++
diff --git a/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr b/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
index dafe1c1d39503..6eecb8a38770f 100644
--- a/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
+++ b/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Fun::F`
|
LL | type F<'a>: Fn() -> u32;
| ^^^^^^^^^^^ required by this bound in `Fun::F`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Fn()`
|
LL | impl<T: Fn()> Fun for T {
| ++++++
diff --git a/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr b/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
index ecb337bbceb91..c2d5a8ed48dd4 100644
--- a/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
+++ b/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
@@ -13,7 +13,7 @@ note: required by a bound in `UnsafeCopy::Item`
|
LL | type Item<'a>: std::ops::Deref<Target = T>;
| ^^^^^^^^^^ required by this bound in `UnsafeCopy::Item`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `<Target = T>`
|
LL | impl<T: Copy + std::ops::Deref<Target = T>> UnsafeCopy<T> for T {
| ++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-74824.current.stderr b/tests/ui/generic-associated-types/issue-74824.current.stderr
index 231136612a051..7e245181444f2 100644
--- a/tests/ui/generic-associated-types/issue-74824.current.stderr
+++ b/tests/ui/generic-associated-types/issue-74824.current.stderr
@@ -23,7 +23,7 @@ note: required by a bound in `UnsafeCopy::Copy`
|
LL | type Copy<T>: Copy = Box<T>;
| ^^^^ required by this bound in `UnsafeCopy::Copy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::clone::Clone`
|
LL | type Copy<T: std::clone::Clone>: Copy = Box<T>;
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-74824.next.stderr b/tests/ui/generic-associated-types/issue-74824.next.stderr
index 231136612a051..7e245181444f2 100644
--- a/tests/ui/generic-associated-types/issue-74824.next.stderr
+++ b/tests/ui/generic-associated-types/issue-74824.next.stderr
@@ -23,7 +23,7 @@ note: required by a bound in `UnsafeCopy::Copy`
|
LL | type Copy<T>: Copy = Box<T>;
| ^^^^ required by this bound in `UnsafeCopy::Copy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::clone::Clone`
|
LL | type Copy<T: std::clone::Clone>: Copy = Box<T>;
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/missing-bounds.stderr b/tests/ui/generic-associated-types/missing-bounds.stderr
index 1d7d80d1b0768..2e3667f55e3c9 100644
--- a/tests/ui/generic-associated-types/missing-bounds.stderr
+++ b/tests/ui/generic-associated-types/missing-bounds.stderr
@@ -35,7 +35,7 @@ note: tuple struct defined here
|
LL | struct A<B>(B);
| ^
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `<Output = B>`
|
LL | impl<B> Add for A<B> where B: Add<Output = B> {
| ++++++++++++
@@ -58,7 +58,7 @@ note: tuple struct defined here
|
LL | struct C<B>(B);
| ^
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `<Output = B>`
|
LL | impl<B: Add<Output = B>> Add for C<B> {
| ++++++++++++
@@ -71,7 +71,7 @@ LL | Self(self.0 + rhs.0)
| |
| B
|
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `std::ops::Add<Output = B>`
|
LL | impl<B: std::ops::Add<Output = B>> Add for D<B> {
| +++++++++++++++++++++++++++
@@ -94,7 +94,7 @@ note: tuple struct defined here
|
LL | struct E<B>(B);
| ^
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `<Output = B>`
|
LL | impl<B: Add<Output = B>> Add for E<B> where <B as Add>::Output = B {
| ++++++++++++
diff --git a/tests/ui/higher-ranked/structually-relate-aliases.stderr b/tests/ui/higher-ranked/structually-relate-aliases.stderr
index cf3e4cc85b912..0eb147d81933b 100644
--- a/tests/ui/higher-ranked/structually-relate-aliases.stderr
+++ b/tests/ui/higher-ranked/structually-relate-aliases.stderr
@@ -5,7 +5,7 @@ error[E0277]: the trait bound `for<'a> T: ToUnit<'a>` is not satisfied
LL | impl<T> Overlap<for<'a> fn(&'a (), Assoc<'a, T>)> for T {}
| ^^^^^^^^^^^^ the trait `for<'a> ToUnit<'a>` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `for<'a> ToUnit<'a>`
|
LL | impl<T: for<'a> ToUnit<'a>> Overlap<for<'a> fn(&'a (), Assoc<'a, T>)> for T {}
| ++++++++++++++++++++
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
index e10da26665ebb..fd23f3f128914 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
@@ -13,7 +13,7 @@ LL | fn want_bar_for_any_ccx<B>(b: &B)
| -------------------- required by a bound in this function
LL | where B : for<'ccx> Bar<'ccx>
| ^^^^^^^^^^^^^^^^^^^ required by this bound in `want_bar_for_any_ccx`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `for<'ccx> Bar<'ccx>`
|
LL | where B : Qux + for<'ccx> Bar<'ccx>
| +++++++++++++++++++++
diff --git a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.stderr b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.stderr
index e60531a876be1..1eaf3e4ca64e3 100644
--- a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `for<'a> T: SomeTrait<'a>` is not satisfied
LL | callee::<fn(&()) -> <T as SomeTrait<'_>>::Associated>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> SomeTrait<'a>` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `for<'a> SomeTrait<'a>`
|
LL | fn give_me_ice<T: for<'a> SomeTrait<'a>>() {
| +++++++++++++++++++++++
@@ -15,7 +15,7 @@ error[E0277]: the trait bound `for<'a> T: SomeTrait<'a>` is not satisfied
LL | callee::<fn(&()) -> <T as SomeTrait<'_>>::Associated>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> SomeTrait<'a>` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `for<'a> SomeTrait<'a>`
|
LL | fn give_me_ice<T: for<'a> SomeTrait<'a>>() {
| +++++++++++++++++++++++
diff --git a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
index 38c7a9ea16e64..47c0d1df8a48a 100644
--- a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
+++ b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
@@ -17,7 +17,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| ------- ^^^^^^^^^^^ ^
| |
| unsatisfied trait bound introduced here
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `MyFn<i32>`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -43,7 +43,7 @@ LL | fn autobatch<F>(self) -> impl Trait
...
LL | F: Callback<Self::CallbackArg>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<Sender as ChannelSender>::autobatch`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `MyFn<i32>`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -68,7 +68,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `MyFn<i32>`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -121,7 +121,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `MyFn<i32>`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -137,7 +137,7 @@ note: required by a bound in `Callback`
|
LL | trait Callback<A>: MyFn<A, Output = Self::Ret> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Callback`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `MyFn<i32>`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
diff --git a/tests/ui/impl-trait/issue-55872-1.stderr b/tests/ui/impl-trait/issue-55872-1.stderr
index 2ccca0b562c06..caca075a600bc 100644
--- a/tests/ui/impl-trait/issue-55872-1.stderr
+++ b/tests/ui/impl-trait/issue-55872-1.stderr
@@ -17,7 +17,7 @@ LL | (S::default(), T::default())
| ---------------------------- return type was inferred to be `(S, T)` here
|
= note: required because it appears within the type `(S, T)`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Copy`
|
LL | impl<S: Default + std::marker::Copy> Bar for S {
| +++++++++++++++++++
@@ -32,7 +32,7 @@ LL | (S::default(), T::default())
| ---------------------------- return type was inferred to be `(S, T)` here
|
= note: required because it appears within the type `(S, T)`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Copy`
|
LL | fn foo<T: Default + std::marker::Copy>() -> Self::E {
| +++++++++++++++++++
diff --git a/tests/ui/impl-trait/normalize-tait-in-const.stderr b/tests/ui/impl-trait/normalize-tait-in-const.stderr
index 203fbfc1d2c55..9054b621bced6 100644
--- a/tests/ui/impl-trait/normalize-tait-in-const.stderr
+++ b/tests/ui/impl-trait/normalize-tait-in-const.stderr
@@ -33,7 +33,7 @@ LL | fun(filter_positive());
| ^^^^^^^^^^^^^^^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const Fn(&foo::Alias<'_>)`
|
LL | const fn with_positive<F: for<'a> ~const Fn(&'a Alias<'a>) + ~const Destruct + ~const Fn(&foo::Alias<'_>)>(fun: F) {
| ++++++++++++++++++++++++++++
diff --git a/tests/ui/issues/issue-6738.stderr b/tests/ui/issues/issue-6738.stderr
index 9c25c0fd9a142..74f0d6341a739 100644
--- a/tests/ui/issues/issue-6738.stderr
+++ b/tests/ui/issues/issue-6738.stderr
@@ -6,7 +6,7 @@ LL | self.x += v.x;
| |
| cannot use `+=` on type `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::ops::AddAssign`
|
LL | impl<T: std::ops::AddAssign> Foo<T> {
| +++++++++++++++++++++
diff --git a/tests/ui/kindck/kindck-impl-type-params.stderr b/tests/ui/kindck/kindck-impl-type-params.stderr
index da9a8e5532c33..4cc5219c97ca6 100644
--- a/tests/ui/kindck/kindck-impl-type-params.stderr
+++ b/tests/ui/kindck/kindck-impl-type-params.stderr
@@ -12,7 +12,7 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&S<T>` to `&dyn Gettable<T>`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Send`
|
LL | fn f<T: std::marker::Send>(val: T) {
| +++++++++++++++++++
@@ -31,7 +31,7 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&S<T>` to `&dyn Gettable<T>`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | fn f<T: std::marker::Copy>(val: T) {
| +++++++++++++++++++
@@ -50,7 +50,7 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&S<T>` to `&dyn Gettable<T>`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Send`
|
LL | fn g<T: std::marker::Send>(val: T) {
| +++++++++++++++++++
@@ -69,7 +69,7 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&S<T>` to `&dyn Gettable<T>`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | fn g<T: std::marker::Copy>(val: T) {
| +++++++++++++++++++
diff --git a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
index 17506dadb9f7b..f4007e34a12da 100644
--- a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
+++ b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
@@ -6,7 +6,7 @@ LL | impl<A, B> FnOnce<A> for CachedFun<A, B>
|
note: required by a bound in `FnOnce`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound but it is an `unstable` trait
+help: consider further restricting this bound with unstable trait `std::marker::Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -19,7 +19,7 @@ LL | impl<A, B> FnMut<A> for CachedFun<A, B>
|
note: required by a bound in `FnMut`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound but it is an `unstable` trait
+help: consider further restricting this bound with unstable trait `std::marker::Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
LL | extern "rust-call" fn call_once(mut self, a: A) -> Self::Output {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
|
-help: consider further restricting this bound but it is an `unstable` trait
+help: consider further restricting this bound with unstable trait `std::marker::Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -41,7 +41,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
LL | extern "rust-call" fn call_mut(&mut self, a: A) -> Self::Output {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
|
-help: consider further restricting this bound but it is an `unstable` trait
+help: consider further restricting this bound with unstable trait `std::marker::Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -56,7 +56,7 @@ LL | self.call_mut(a)
|
note: required by a bound in `call_mut`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound but it is an `unstable` trait
+help: consider further restricting this bound with unstable trait `std::marker::Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
diff --git a/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr b/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
index bd8095224a720..70497504bb088 100644
--- a/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
+++ b/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
@@ -4,7 +4,7 @@ error[E0277]: cannot multiply `T` by `T`
LL | type Alias<T> = <T as std::ops::Mul>::Output;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `T * T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::ops::Mul`
|
LL | type Alias<T: std::ops::Mul> = <T as std::ops::Mul>::Output;
| +++++++++++++++
diff --git a/tests/ui/methods/filter-relevant-fn-bounds.stderr b/tests/ui/methods/filter-relevant-fn-bounds.stderr
index b737c0ab11fd4..da11c332797be 100644
--- a/tests/ui/methods/filter-relevant-fn-bounds.stderr
+++ b/tests/ui/methods/filter-relevant-fn-bounds.stderr
@@ -8,7 +8,7 @@ LL | | where
LL | | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| |___________________________________________________^ the trait `for<'a> Output<'a>` is not implemented for `F`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `for<'a> Output<'a>`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + for<'a> Output<'a>,
| ++++++++++++++++++++
@@ -19,7 +19,7 @@ error[E0277]: the trait bound `for<'a> F: Output<'a>` is not satisfied
LL | fn do_something_wrapper<O, F>(self, _: F)
| ^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> Output<'a>` is not implemented for `F`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `for<'a> Output<'a>`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + for<'a> Output<'a>,
| ++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0277]: the trait bound `F: Output<'_>` is not satisfied
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Output<'_>` is not implemented for `F`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Output<'_>`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + Output<'_>,
| ++++++++++++
@@ -41,7 +41,7 @@ error[E0277]: the trait bound `F: Output<'_>` is not satisfied
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Output<'_>` is not implemented for `F`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Output<'_>`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + Output<'_>,
| ++++++++++++
diff --git a/tests/ui/mir/validate/validate-unsize-cast.stderr b/tests/ui/mir/validate/validate-unsize-cast.stderr
index 513e1e597bf57..d2ba786d5d594 100644
--- a/tests/ui/mir/validate/validate-unsize-cast.stderr
+++ b/tests/ui/mir/validate/validate-unsize-cast.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `CastTo`
|
LL | pub trait CastTo<U: ?Sized>: Unsize<U> {}
| ^^^^^^^^^ required by this bound in `CastTo`
-help: consider further restricting this bound but it is an `unstable` trait
+help: consider further restricting this bound with unstable trait `std::marker::Unsize<U>`
|
LL | impl<T: ?Sized + std::marker::Unsize<U>, U: ?Sized> CastTo<U> for T {}
| ++++++++++++++++++++++++
diff --git a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr b/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
index b3089cecfbb29..d7fdbcce5bc57 100644
--- a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
+++ b/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
@@ -6,7 +6,7 @@ LL | let _ = s == t;
| |
| &[T]
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::cmp::PartialEq`
|
LL | pub fn foo<T: std::cmp::PartialEq>(s: &[T], t: &[T]) {
| +++++++++++++++++++++
diff --git a/tests/ui/moves/issue-34721.stderr b/tests/ui/moves/issue-34721.stderr
index 94780a04c1f29..30b94072e5e8c 100644
--- a/tests/ui/moves/issue-34721.stderr
+++ b/tests/ui/moves/issue-34721.stderr
@@ -18,7 +18,7 @@ note: `Foo::zero` takes ownership of the receiver `self`, which moves `x`
|
LL | fn zero(self) -> Self;
| ^^^^
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | pub fn baz<T: Foo + Copy>(x: T) -> T {
| ++++++
diff --git a/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr b/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
index c03204c7b9f10..92fe54e3d892e 100644
--- a/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
+++ b/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
@@ -17,7 +17,7 @@ LL | fn duplicate_t<T>(t: T) -> (T, T) {
...
LL | (t, t)
| - you could clone this value
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn duplicate_t<T: Copy>(t: T) -> (T, T) {
| ++++++
@@ -33,7 +33,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn duplicate_opt<T: Copy>(t: Option<T>) -> (Option<T>, Option<T>) {
| ++++++
@@ -49,7 +49,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn duplicate_tup1<T: Copy>(t: (T,)) -> ((T,), (T,)) {
| ++++++
@@ -81,7 +81,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with traits `Copy + Trait`
|
LL | fn duplicate_custom<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) {
| ++++++++++++++
@@ -97,7 +97,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with traits `Copy + Trait`
|
LL | fn duplicate_custom_1<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) where {
| ++++++++++++++
@@ -113,7 +113,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound
+help: consider further restricting this bound with traits `Copy + Trait`
|
LL | T: A + Copy + Trait,
| ++++++++++++++
@@ -129,7 +129,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound
+help: consider further restricting this bound with traits `Copy + Trait`
|
LL | T: A + Copy + Trait,
| ++++++++++++++
@@ -145,7 +145,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound
+help: consider further restricting this bound with traits `Copy + Trait`
|
LL | fn duplicate_custom_4<T: A + Copy + Trait>(t: S<T>) -> (S<T>, S<T>)
| ++++++++++++++
@@ -169,7 +169,7 @@ LL | fn existing_colon<T:>(t: T) {
...
LL | [t, t];
| - you could clone this value
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn existing_colon<T: Copy>(t: T) {
| ++++
@@ -193,7 +193,7 @@ LL | fn existing_colon_in_where<T>(t: T)
...
LL | [t, t];
| - you could clone this value
-help: consider further restricting type parameter `T`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | T:, T: Copy
| ~~~~~~~~~
diff --git a/tests/ui/phantom-auto-trait.stderr b/tests/ui/phantom-auto-trait.stderr
index 5af648f6a0cf1..cc2ddde39737c 100644
--- a/tests/ui/phantom-auto-trait.stderr
+++ b/tests/ui/phantom-auto-trait.stderr
@@ -23,7 +23,7 @@ note: required by a bound in `is_zen`
|
LL | fn is_zen<T: Zen>(_: T) {}
| ^^^ required by this bound in `is_zen`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Sync`
|
LL | fn not_sync<T: std::marker::Sync>(x: Guard<T>) {
| +++++++++++++++++++
@@ -58,7 +58,7 @@ note: required by a bound in `is_zen`
|
LL | fn is_zen<T: Zen>(_: T) {}
| ^^^ required by this bound in `is_zen`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Sync`
|
LL | fn nested_not_sync<T: std::marker::Sync>(x: Nested<Guard<T>>) {
| +++++++++++++++++++
diff --git a/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr b/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
index b17d1e0ab1136..37e0ef0408562 100644
--- a/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
+++ b/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `for<'z> T: Trait2<'y, 'z>` is not satisfied
LL | fn callee<'x, 'y, T>(t: &'x dyn for<'z> Trait1< <T as Trait2<'y, 'z>>::Foo >)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'z> Trait2<'y, 'z>` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `for<'z> Trait2<'y, 'z>`
|
LL | fn callee<'x, 'y, T: for<'z> Trait2<'y, 'z>>(t: &'x dyn for<'z> Trait1< <T as Trait2<'y, 'z>>::Foo >)
| ++++++++++++++++++++++++
@@ -17,7 +17,7 @@ LL | |
LL | | }
| |_^ the trait `for<'z> Trait2<'y, 'z>` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `for<'z> Trait2<'y, 'z>`
|
LL | fn callee<'x, 'y, T: for<'z> Trait2<'y, 'z>>(t: &'x dyn for<'z> Trait1< <T as Trait2<'y, 'z>>::Foo >)
| ++++++++++++++++++++++++
diff --git a/tests/ui/resolve/issue-55673.stderr b/tests/ui/resolve/issue-55673.stderr
index 4069b35a99848..7d420126199b1 100644
--- a/tests/ui/resolve/issue-55673.stderr
+++ b/tests/ui/resolve/issue-55673.stderr
@@ -15,7 +15,7 @@ error[E0220]: associated type `Baa` not found for `T`
LL | T::Baa: std::fmt::Debug,
| ^^^ there is a similarly named associated type `Bar` in the trait `Foo`
|
-help: consider further restricting type parameter `T`
+help: consider further restricting type parameter `T` with trait `Foo`
|
LL | T::Baa: std::fmt::Debug, T: Foo
| ~~~~~~~~
diff --git a/tests/ui/specialization/default-generic-associated-type-bound.stderr b/tests/ui/specialization/default-generic-associated-type-bound.stderr
index afdbe2eb22677..d14026281ed95 100644
--- a/tests/ui/specialization/default-generic-associated-type-bound.stderr
+++ b/tests/ui/specialization/default-generic-associated-type-bound.stderr
@@ -20,7 +20,7 @@ note: required by a bound in `X::U`
|
LL | type U<'a>: PartialEq<&'a Self> where Self: 'a;
| ^^^^^^^^^^^^^^^^^^^ required by this bound in `X::U`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::cmp::PartialEq`
|
LL | impl<T: 'static + std::cmp::PartialEq> X for T {
| +++++++++++++++++++++
diff --git a/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr b/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
index 01188e293bd97..b3a53c95cd57c 100644
--- a/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
@@ -19,7 +19,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo<'a, T: Eq + 'a> { }
| ^^ required by this bound in `Foo`
-help: consider restricting type parameter `U`
+help: consider restricting type parameter `U` with trait `std::cmp::Eq`
|
LL | default impl<U: std::cmp::Eq> Foo<'static, U> for () {}
| ++++++++++++++
diff --git a/tests/ui/specialization/issue-33017.stderr b/tests/ui/specialization/issue-33017.stderr
index 2c20077078fd3..e04af087b5c8d 100644
--- a/tests/ui/specialization/issue-33017.stderr
+++ b/tests/ui/specialization/issue-33017.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `UncheckedCopy::Output`
|
LL | type Output: From<Self> + Copy + Into<Self>;
| ^^^^ required by this bound in `UncheckedCopy::Output`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> UncheckedCopy for T {
| +++++++++++++++++++
diff --git a/tests/ui/specialization/min_specialization/issue-79224.stderr b/tests/ui/specialization/min_specialization/issue-79224.stderr
index 268fc3a959167..ebf7ee08a68a1 100644
--- a/tests/ui/specialization/min_specialization/issue-79224.stderr
+++ b/tests/ui/specialization/min_specialization/issue-79224.stderr
@@ -5,7 +5,7 @@ LL | impl<B: ?Sized> Display for Cow<'_, B> {
| ^^^^^^^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::clone::Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -17,7 +17,7 @@ LL | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::clone::Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -29,7 +29,7 @@ LL | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
| ^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::clone::Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -47,7 +47,7 @@ LL | | }
| |_____^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::clone::Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/assoc-const-as-fn.stderr b/tests/ui/suggestions/assoc-const-as-fn.stderr
index 69e9af726479e..b660bacd50ba8 100644
--- a/tests/ui/suggestions/assoc-const-as-fn.stderr
+++ b/tests/ui/suggestions/assoc-const-as-fn.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `T: GlUniformScalar` is not satisfied
LL | <T as GlUniformScalar>::FACTORY(1, value);
| ^ the trait `GlUniformScalar` is not implemented for `T`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `GlUniformScalar`
|
LL | pub fn foo<T: UniformScalar + GlUniformScalar>(value: T) {
| +++++++++++++++++
diff --git a/tests/ui/suggestions/bound-suggestions.stderr b/tests/ui/suggestions/bound-suggestions.stderr
index 4965e7439f849..d4db21ff7b53e 100644
--- a/tests/ui/suggestions/bound-suggestions.stderr
+++ b/tests/ui/suggestions/bound-suggestions.stderr
@@ -5,7 +5,7 @@ LL | println!("{:?}", t);
| ^ `impl Sized` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::fmt::Debug`
|
LL | fn test_impl(t: impl Sized + std::fmt::Debug) {
| +++++++++++++++++
@@ -17,7 +17,7 @@ LL | println!("{:?}", t);
| ^ `T` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::fmt::Debug`
|
LL | fn test_no_bounds<T: std::fmt::Debug>(t: T) {
| +++++++++++++++++
@@ -29,7 +29,7 @@ LL | println!("{:?}", t);
| ^ `T` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::fmt::Debug`
|
LL | fn test_one_bound<T: Sized + std::fmt::Debug>(t: T) {
| +++++++++++++++++
@@ -41,7 +41,7 @@ LL | println!("{:?} {:?}", x, y);
| ^ `Y` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting type parameter `Y`
+help: consider further restricting type parameter `Y` with trait `std::fmt::Debug`
|
LL | fn test_no_bounds_where<X, Y>(x: X, y: Y) where X: std::fmt::Debug, Y: std::fmt::Debug {
| ~~~~~~~~~~~~~~~~~~~~
@@ -53,7 +53,7 @@ LL | println!("{:?}", x);
| ^ `X` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::fmt::Debug`
|
LL | fn test_one_bound_where<X>(x: X) where X: Sized + std::fmt::Debug {
| +++++++++++++++++
@@ -65,7 +65,7 @@ LL | println!("{:?}", x);
| ^ `X` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::fmt::Debug`
|
LL | fn test_many_bounds_where<X>(x: X) where X: Sized + std::fmt::Debug, X: Sized {
| +++++++++++++++++
diff --git a/tests/ui/suggestions/clone-bounds-121524.stderr b/tests/ui/suggestions/clone-bounds-121524.stderr
index 6d60508a4a14c..a389dee5e9e32 100644
--- a/tests/ui/suggestions/clone-bounds-121524.stderr
+++ b/tests/ui/suggestions/clone-bounds-121524.stderr
@@ -9,7 +9,7 @@ note: this `clone()` copies the reference, which does not do anything, because `
|
LL | drops_impl_owned(thing.clone());
| ^^^^^
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Clone`
|
LL | fn clones_impl_ref_inline(thing: &impl DoesAThing + Clone) {
| +++++++
diff --git a/tests/ui/suggestions/clone-on-unconstrained-borrowed-type-param.stderr b/tests/ui/suggestions/clone-on-unconstrained-borrowed-type-param.stderr
index afbb9c32d516e..03a14b03781e3 100644
--- a/tests/ui/suggestions/clone-on-unconstrained-borrowed-type-param.stderr
+++ b/tests/ui/suggestions/clone-on-unconstrained-borrowed-type-param.stderr
@@ -15,7 +15,7 @@ note: `T` does not implement `Clone`, so `&T` was cloned instead
|
LL | t.clone()
| ^
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Clone`
|
LL | fn wat<T: Clone>(t: &T) -> T {
| +++++++
diff --git a/tests/ui/suggestions/derive-clone-for-eq.stderr b/tests/ui/suggestions/derive-clone-for-eq.stderr
index 680890e880ca6..6fb331057f445 100644
--- a/tests/ui/suggestions/derive-clone-for-eq.stderr
+++ b/tests/ui/suggestions/derive-clone-for-eq.stderr
@@ -14,7 +14,7 @@ LL | impl<T: Clone, U> PartialEq<U> for Struct<T>
note: required by a bound in `Eq`
--> $SRC_DIR/core/src/cmp.rs:LL:COL
= note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::clone::Clone`
|
LL | pub struct Struct<T: std::clone::Clone>(T);
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/derive-macro-missing-bounds.stderr b/tests/ui/suggestions/derive-macro-missing-bounds.stderr
index bffcb1af487e9..8df2fcd992de5 100644
--- a/tests/ui/suggestions/derive-macro-missing-bounds.stderr
+++ b/tests/ui/suggestions/derive-macro-missing-bounds.stderr
@@ -38,7 +38,7 @@ LL | impl<T: Debug + Trait> Debug for Inner<T> {
= note: required for `&c::Inner<T>` to implement `Debug`
= note: required for the cast from `&&c::Inner<T>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `c::Trait`
|
LL | struct Outer<T: c::Trait>(Inner<T>);
| ++++++++++
@@ -60,7 +60,7 @@ LL | impl<T> Debug for Inner<T> where T: Debug, T: Trait {
= note: required for `&d::Inner<T>` to implement `Debug`
= note: required for the cast from `&&d::Inner<T>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `d::Trait`
|
LL | struct Outer<T: d::Trait>(Inner<T>);
| ++++++++++
@@ -82,7 +82,7 @@ LL | impl<T> Debug for Inner<T> where T: Debug + Trait {
= note: required for `&e::Inner<T>` to implement `Debug`
= note: required for the cast from `&&e::Inner<T>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `e::Trait`
|
LL | struct Outer<T: e::Trait>(Inner<T>);
| ++++++++++
@@ -104,7 +104,7 @@ LL | impl<T: Debug> Debug for Inner<T> where T: Trait {
= note: required for `&f::Inner<T>` to implement `Debug`
= note: required for the cast from `&&f::Inner<T>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `f::Trait`
|
LL | struct Outer<T: f::Trait>(Inner<T>);
| ++++++++++
diff --git a/tests/ui/suggestions/issue-106443-sugg-clone-for-bound.stderr b/tests/ui/suggestions/issue-106443-sugg-clone-for-bound.stderr
index 8607917ede6bf..474de6388e3dd 100644
--- a/tests/ui/suggestions/issue-106443-sugg-clone-for-bound.stderr
+++ b/tests/ui/suggestions/issue-106443-sugg-clone-for-bound.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `&T: X` is not satisfied
LL | foo(s);
| ^ the trait `X` is not implemented for `&T`
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Clone`
|
LL | fn bar<T: X + Clone>(s: &T) {
| +++++++
diff --git a/tests/ui/suggestions/issue-97677.stderr b/tests/ui/suggestions/issue-97677.stderr
index 0e95167d8515b..c1054204e775f 100644
--- a/tests/ui/suggestions/issue-97677.stderr
+++ b/tests/ui/suggestions/issue-97677.stderr
@@ -6,7 +6,7 @@ LL | n + 10
| |
| N
|
-help: consider restricting type parameter `N`
+help: consider restricting type parameter `N` with trait `std::ops::Add<i32, Output = N>`
|
LL | fn add_ten<N: std::ops::Add<i32, Output = N>>(n: N) -> N {
| ++++++++++++++++++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
index d65ad109241a7..1b2042fa7a4d8 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -32,7 +32,7 @@ LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: required for the cast from `&Vector2<K>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -52,7 +52,7 @@ note: required by a bound in `Vector2`
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -74,7 +74,7 @@ LL | #[derive(Debug, Copy, Clone)]
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
index 2ade0e974e495..bf422221f6e6b 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
@@ -13,7 +13,7 @@ note: the `Copy` impl for `Vector2<K>` requires that `K: Debug`
LL | pub loc: Vector2<K>,
| ^^^^^^^^^^
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Debug`
|
LL | pub struct AABB<K: Copy + Debug>{
| +++++++
@@ -29,7 +29,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone>{
| ^^^^^ required by this bound in `Vector2`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::fmt::Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
@@ -44,7 +44,7 @@ LL | pub loc: Vector2<K>,
| ^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::fmt::Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
@@ -59,7 +59,7 @@ LL | pub size: Vector2<K>
| ^^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::fmt::Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
index 316c2fa0fc960..a1a3e84acf6a4 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
@@ -13,7 +13,7 @@ note: the `Copy` impl for `Vector2<K>` requires that `K: Debug`
LL | pub loc: Vector2<K>,
| ^^^^^^^^^^
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `Debug`
|
LL | pub struct AABB<K: Debug> {
| +++++++
@@ -29,7 +29,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^^ required by this bound in `Vector2`
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `std::fmt::Debug`
|
LL | pub struct AABB<K: std::fmt::Debug> {
| +++++++++++++++++
@@ -45,7 +45,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `std::marker::Copy`
|
LL | pub struct AABB<K: std::marker::Copy> {
| +++++++++++++++++++
@@ -68,7 +68,7 @@ LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: required for the cast from `&Vector2<K>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `std::marker::Copy`
|
LL | pub struct AABB<K: std::marker::Copy> {
| +++++++++++++++++++
@@ -83,7 +83,7 @@ LL | pub loc: Vector2<K>,
| ^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `std::fmt::Debug`
|
LL | pub struct AABB<K: std::fmt::Debug> {
| +++++++++++++++++
@@ -103,7 +103,7 @@ note: required by a bound in `Vector2`
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `std::marker::Copy`
|
LL | pub struct AABB<K: std::marker::Copy> {
| +++++++++++++++++++
@@ -118,7 +118,7 @@ LL | pub size: Vector2<K>,
| ^^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `std::fmt::Debug`
|
LL | pub struct AABB<K: std::fmt::Debug> {
| +++++++++++++++++
@@ -140,7 +140,7 @@ LL | #[derive(Debug, Copy, Clone)]
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `std::marker::Copy`
|
LL | pub struct AABB<K: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr b/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
index 23a75154f2008..327589ba7a88a 100644
--- a/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
+++ b/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
@@ -12,7 +12,7 @@ note: the `Copy` impl for `OnlyCopyIfDisplay<S>` requires that `S: std::fmt::Dis
|
LL | struct Wrapper<T>(T);
| ^
-help: consider restricting type parameter `S`
+help: consider restricting type parameter `S` with trait `std::fmt::Display`
|
LL | impl<S: std::fmt::Display> Copy for Wrapper<OnlyCopyIfDisplay<S>> {}
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr b/tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr
index c9f277fb3501a..b22aa35ef6d47 100644
--- a/tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr
+++ b/tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr
@@ -7,7 +7,7 @@ LL |
LL | impl<S> Copy for Wrapper<S> {}
| ^^^^^^^^^^
|
-help: consider restricting type parameter `S`
+help: consider restricting type parameter `S` with trait `Copy`
|
LL | impl<S: Copy> Copy for Wrapper<S> {}
| ++++++
diff --git a/tests/ui/suggestions/restrict-existing-type-bounds.stderr b/tests/ui/suggestions/restrict-existing-type-bounds.stderr
index fe8338c18c2bd..8fff4ca5d95fb 100644
--- a/tests/ui/suggestions/restrict-existing-type-bounds.stderr
+++ b/tests/ui/suggestions/restrict-existing-type-bounds.stderr
@@ -20,7 +20,7 @@ LL | Ok(self)
| this argument influences the type of `Ok`
note: tuple variant defined here
--> $SRC_DIR/core/src/result.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `<Output = T>`
|
LL | impl<T: TryAdd<Output = T>> TryAdd for Option<T> {
| ++++++++++++
@@ -47,7 +47,7 @@ LL | Ok(self)
| this argument influences the type of `Ok`
note: tuple variant defined here
--> $SRC_DIR/core/src/result.rs:LL:COL
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `, Output = T`
|
LL | impl<T: TryAdd<Error = X, Output = T>> TryAdd for Other<T> {
| ++++++++++++
diff --git a/tests/ui/suggestions/restrict-type-argument.stderr b/tests/ui/suggestions/restrict-type-argument.stderr
index 01c2de7986419..4ac9c2d310ca6 100644
--- a/tests/ui/suggestions/restrict-type-argument.stderr
+++ b/tests/ui/suggestions/restrict-type-argument.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | fn use_impl_sync(val: impl Sync + std::marker::Send) {
| +++++++++++++++++++
@@ -29,7 +29,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | fn use_where<S>(val: S) where S: Sync + std::marker::Send {
| +++++++++++++++++++
@@ -47,7 +47,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | fn use_bound<S: Sync + std::marker::Send>(val: S) {
| +++++++++++++++++++
@@ -65,7 +65,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | Sync + std::marker::Send
| +++++++++++++++++++
@@ -83,7 +83,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | fn use_bound_and_where<S: Sync + std::marker::Send>(val: S) where S: std::fmt::Debug {
| +++++++++++++++++++
@@ -101,7 +101,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider restricting type parameter `S`
+help: consider restricting type parameter `S` with trait `std::marker::Send`
|
LL | fn use_unbound<S: std::marker::Send>(val: S) {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/trait-impl-bound-suggestions.stderr b/tests/ui/suggestions/trait-impl-bound-suggestions.stderr
index 6a75cbdf63974..c62b2dd77d363 100644
--- a/tests/ui/suggestions/trait-impl-bound-suggestions.stderr
+++ b/tests/ui/suggestions/trait-impl-bound-suggestions.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ConstrainedStruct`
|
LL | struct ConstrainedStruct<X: Copy> {
| ^^^^ required by this bound in `ConstrainedStruct`
-help: consider further restricting type parameter `X`
+help: consider further restricting type parameter `X` with trait `std::marker::Copy`
|
LL | trait InsufficientlyConstrainedGeneric<X=()> where Self: Sized, X: std::marker::Copy {
| ++++++++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound in `ConstrainedStruct`
|
LL | struct ConstrainedStruct<X: Copy> {
| ^^^^ required by this bound in `ConstrainedStruct`
-help: consider further restricting type parameter `X`
+help: consider further restricting type parameter `X` with trait `std::marker::Copy`
|
LL | trait InsufficientlyConstrainedGenericWithEmptyWhere<X=()> where Self: Sized, X: std::marker::Copy {
| ++++++++++++++++++++++
@@ -41,7 +41,7 @@ note: required by a bound in `ConstrainedStruct`
|
LL | struct ConstrainedStruct<X: Copy> {
| ^^^^ required by this bound in `ConstrainedStruct`
-help: consider further restricting type parameter `X`
+help: consider further restricting type parameter `X` with trait `std::marker::Copy`
|
LL | trait InsufficientlyConstrainedGeneric<X=()> where Self: Sized, X: std::marker::Copy {
| ++++++++++++++++++++++
@@ -57,7 +57,7 @@ note: required by a bound in `ConstrainedStruct`
|
LL | struct ConstrainedStruct<X: Copy> {
| ^^^^ required by this bound in `ConstrainedStruct`
-help: consider further restricting type parameter `X`
+help: consider further restricting type parameter `X` with trait `std::marker::Copy`
|
LL | trait InsufficientlyConstrainedGenericWithEmptyWhere<X=()> where Self: Sized, X: std::marker::Copy {
| ++++++++++++++++++++++
diff --git a/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr b/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
index 7aa32557af2de..c1dda283d9d13 100644
--- a/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
+++ b/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
@@ -11,7 +11,7 @@ LL | return a.bar();
= note: expected type parameter `B`
found associated type `<A as MyTrait>::T`
= note: the caller chooses a type for `B` which can be different from `<A as MyTrait>::T`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `<T = B>`
|
LL | pub fn foo<A: MyTrait<T = B>, B>(a: A) -> B {
| +++++++
diff --git a/tests/ui/trait-bounds/unstable-trait-suggestion.rs b/tests/ui/trait-bounds/unstable-trait-suggestion.rs
index fff61e4a6f5f1..c49e2a3403326 100644
--- a/tests/ui/trait-bounds/unstable-trait-suggestion.rs
+++ b/tests/ui/trait-bounds/unstable-trait-suggestion.rs
@@ -9,7 +9,7 @@ pub trait Unstable {}
fn foo<T: Unstable>(_: T) {}
#[stable(feature = "unit_test", since = "1.0.0")]
-pub fn demo<T>(t: T) { //~ HELP consider restricting type parameter `T` but it is an `unstable` trait
+pub fn demo<T>(t: T) { //~ HELP consider restricting type parameter `T` with unstable trait `Unstable`
foo(t) //~ ERROR E0277
}
fn main() {}
diff --git a/tests/ui/trait-bounds/unstable-trait-suggestion.stderr b/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
index 7b5e9f8d124a7..a326965b683d5 100644
--- a/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
+++ b/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `foo`
|
LL | fn foo<T: Unstable>(_: T) {}
| ^^^^^^^^ required by this bound in `foo`
-help: consider restricting type parameter `T` but it is an `unstable` trait
+help: consider restricting type parameter `T` with unstable trait `Unstable`
|
LL | pub fn demo<T: Unstable>(t: T) {
| ++++++++++
diff --git a/tests/ui/traits/alias/wf.stderr b/tests/ui/traits/alias/wf.stderr
index 3be6e8a49d692..42b0104e8651b 100644
--- a/tests/ui/traits/alias/wf.stderr
+++ b/tests/ui/traits/alias/wf.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `A`
|
LL | trait A<T: Foo> {}
| ^^^ required by this bound in `A`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Foo`
|
LL | trait B<T: Foo> = A<T>;
| +++++
diff --git a/tests/ui/traits/bad-method-typaram-kind.stderr b/tests/ui/traits/bad-method-typaram-kind.stderr
index 376a83e58a7d3..630c8b791f7b9 100644
--- a/tests/ui/traits/bad-method-typaram-kind.stderr
+++ b/tests/ui/traits/bad-method-typaram-kind.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `Bar::bar`
|
LL | fn bar<T:Send>(&self);
| ^^^^ required by this bound in `Bar::bar`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Send`
|
LL | fn foo<T:'static + std::marker::Send>() {
| +++++++++++++++++++
diff --git a/tests/ui/traits/bound/on-structs-and-enums.stderr b/tests/ui/traits/bound/on-structs-and-enums.stderr
index 606f764852fed..7d6420c648273 100644
--- a/tests/ui/traits/bound/on-structs-and-enums.stderr
+++ b/tests/ui/traits/bound/on-structs-and-enums.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Foo`
|
LL | struct Foo<T:Trait> {
| ^^^^^ required by this bound in `Foo`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | impl<T: Trait> Foo<T> {
| +++++++
@@ -59,7 +59,7 @@ note: required by a bound in `Foo`
|
LL | struct Foo<T:Trait> {
| ^^^^^ required by this bound in `Foo`
-help: consider restricting type parameter `U`
+help: consider restricting type parameter `U` with trait `Trait`
|
LL | struct Badness<U: Trait> {
| +++++++
@@ -75,7 +75,7 @@ note: required by a bound in `Bar`
|
LL | enum Bar<T:Trait> {
| ^^^^^ required by this bound in `Bar`
-help: consider restricting type parameter `V`
+help: consider restricting type parameter `V` with trait `Trait`
|
LL | enum MoreBadness<V: Trait> {
| +++++++
diff --git a/tests/ui/traits/const-traits/call-generic-method-chain.stderr b/tests/ui/traits/const-traits/call-generic-method-chain.stderr
index 9a53c61d0191d..401a85bcc5776 100644
--- a/tests/ui/traits/const-traits/call-generic-method-chain.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-chain.stderr
@@ -42,7 +42,7 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
|
LL | const fn equals_self<T: ~const PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
| ++++++++++++++++++++++++++++
diff --git a/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr b/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
index a168171cfe84b..2598af92f1201 100644
--- a/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
@@ -42,7 +42,7 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
|
LL | const fn equals_self<T: PartialEq + ~const PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
| ++++++++++++++++++++++++++++
@@ -62,7 +62,7 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
|
LL | const fn equals_self2<T: A + ~const PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
| ++++++++++++++++++++++++++++
diff --git a/tests/ui/traits/const-traits/call-generic-method-fail.stderr b/tests/ui/traits/const-traits/call-generic-method-fail.stderr
index 07e50a7f7daae..2a6c0e0ed1d42 100644
--- a/tests/ui/traits/const-traits/call-generic-method-fail.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-fail.stderr
@@ -5,7 +5,7 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
|
LL | pub const fn equals_self<T: PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
| ++++++++++++++++++++++++++++
diff --git a/tests/ui/traits/const-traits/call-generic-method-pass.stderr b/tests/ui/traits/const-traits/call-generic-method-pass.stderr
index af6e6d25dc9be..c46cf8f9ab595 100644
--- a/tests/ui/traits/const-traits/call-generic-method-pass.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-pass.stderr
@@ -28,7 +28,7 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
|
LL | const fn equals_self<T: ~const PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
| ++++++++++++++++++++++++++++
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
index cb4c994bc2f2d..d7b2423f45b5f 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
+++ b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
@@ -19,7 +19,7 @@ LL | x(())
| ^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const FnOnce(())`
|
LL | const fn need_const_closure<T: ~const FnOnce(()) -> i32 + ~const FnOnce(())>(x: T) -> i32 {
| +++++++++++++++++++
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method.stderr b/tests/ui/traits/const-traits/const-closure-trait-method.stderr
index 43af435ae64d7..23de7f521b1f5 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method.stderr
+++ b/tests/ui/traits/const-traits/const-closure-trait-method.stderr
@@ -19,7 +19,7 @@ LL | x(())
| ^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const FnOnce(())`
|
LL | const fn need_const_closure<T: ~const FnOnce(()) -> i32 + ~const FnOnce(())>(x: T) -> i32 {
| +++++++++++++++++++
diff --git a/tests/ui/traits/const-traits/const-closures.stderr b/tests/ui/traits/const-traits/const-closures.stderr
index 2e9e37ba3216d..4a633a5ca2b62 100644
--- a/tests/ui/traits/const-traits/const-closures.stderr
+++ b/tests/ui/traits/const-traits/const-closures.stderr
@@ -61,7 +61,7 @@ LL | f() + f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const Fn()`
|
LL | const fn answer<F: ~const Fn() -> u8 + ~const Fn()>(f: &F) -> u8 {
| +++++++++++++
@@ -73,7 +73,7 @@ LL | f() + f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const Fn()`
|
LL | const fn answer<F: ~const Fn() -> u8 + ~const Fn()>(f: &F) -> u8 {
| +++++++++++++
@@ -85,7 +85,7 @@ LL | f() * 7
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `~const Fn()`
|
LL | F: ~const FnOnce() -> u8 + ~const Fn(),
| +++++++++++++
diff --git a/tests/ui/traits/const-traits/trait-where-clause.stderr b/tests/ui/traits/const-traits/trait-where-clause.stderr
index abe24b662a27f..8a621633b6302 100644
--- a/tests/ui/traits/const-traits/trait-where-clause.stderr
+++ b/tests/ui/traits/const-traits/trait-where-clause.stderr
@@ -33,7 +33,7 @@ note: required by a bound in `Foo::b`
|
LL | fn b() where Self: ~const Bar;
| ^^^^^^^^^^ required by this bound in `Foo::b`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Bar`
|
LL | fn test1<T: Foo + Bar>() {
| +++++
@@ -49,7 +49,7 @@ note: required by a bound in `Foo::c`
|
LL | fn c<T: ~const Bar>();
| ^^^^^^^^^^ required by this bound in `Foo::c`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Bar`
|
LL | fn test1<T: Foo + Bar>() {
| +++++
diff --git a/tests/ui/traits/copy-impl-cannot-normalize.stderr b/tests/ui/traits/copy-impl-cannot-normalize.stderr
index 3bdb8b70172c4..45c26ac9ef46a 100644
--- a/tests/ui/traits/copy-impl-cannot-normalize.stderr
+++ b/tests/ui/traits/copy-impl-cannot-normalize.stderr
@@ -14,7 +14,7 @@ LL | T: TraitFoo,
| -------- unsatisfied trait bound introduced here
note: required by a bound in `Copy`
--> $SRC_DIR/core/src/marker.rs:LL:COL
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `TraitFoo`
|
LL | impl<T: TraitFoo> Copy for Foo<T> {}
| ++++++++++
diff --git a/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr b/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
index 56544dd4def0a..760a9c603ded1 100644
--- a/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
+++ b/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
@@ -12,7 +12,7 @@ note: the `Copy` impl for `Foo<'any>` requires that `'any: 'static`
|
LL | struct Bar<'lt>(Foo<'lt>);
| ^^^^^^^^
-help: consider restricting type parameter `'any`
+help: consider restricting type parameter `'any` with trait `'static`
|
LL | impl<'any: 'static> Copy for Bar<'any> {}
| +++++++++
diff --git a/tests/ui/traits/inductive-overflow/two-traits.stderr b/tests/ui/traits/inductive-overflow/two-traits.stderr
index 6092c194a8757..cb21de08b2975 100644
--- a/tests/ui/traits/inductive-overflow/two-traits.stderr
+++ b/tests/ui/traits/inductive-overflow/two-traits.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Magic::X`
|
LL | type X: Trait;
| ^^^^^ required by this bound in `Magic::X`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::marker::Sync`
|
LL | impl<T: Magic + std::marker::Sync> Magic for T {
| +++++++++++++++++++
diff --git a/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr b/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
index 6f7c9fa11d4b3..c305e668bacb2 100644
--- a/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
+++ b/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
@@ -18,7 +18,7 @@ LL | c.same_as(22)
| |
| required by a bound introduced by this call
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `CompareTo<i32>`
|
LL | fn with_trait<C:CompareToInts + CompareTo<i32>>(c: &C) -> bool {
| ++++++++++++++++
@@ -41,7 +41,7 @@ LL | CompareTo::same_as(c, 22)
| |
| required by a bound introduced by this call
|
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `CompareTo<i32>`
|
LL | fn with_ufcs2<C:CompareToInts + CompareTo<i32>>(c: &C) -> bool {
| ++++++++++++++++
diff --git a/tests/ui/traits/issue-21837.stderr b/tests/ui/traits/issue-21837.stderr
index f198939268802..06e79d40c7d6c 100644
--- a/tests/ui/traits/issue-21837.stderr
+++ b/tests/ui/traits/issue-21837.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Foo`
|
LL | pub struct Foo<T: Bound>(T);
| ^^^^^ required by this bound in `Foo`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Bound`
|
LL | impl<T: Bound> Trait2 for Foo<T> {}
| +++++++
diff --git a/tests/ui/traits/issue-43784-supertrait.stderr b/tests/ui/traits/issue-43784-supertrait.stderr
index 2bf365745a6bd..1dcbaf7c34791 100644
--- a/tests/ui/traits/issue-43784-supertrait.stderr
+++ b/tests/ui/traits/issue-43784-supertrait.stderr
@@ -14,7 +14,7 @@ note: required by a bound in `Complete`
|
LL | pub trait Complete: Partial {
| ^^^^^^^ required by this bound in `Complete`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> Complete for T {}
| +++++++++++++++++++
diff --git a/tests/ui/traits/next-solver/diagnostics/projection-trait-ref.stderr b/tests/ui/traits/next-solver/diagnostics/projection-trait-ref.stderr
index cd8d8b3ffcd38..463e50a2553e4 100644
--- a/tests/ui/traits/next-solver/diagnostics/projection-trait-ref.stderr
+++ b/tests/ui/traits/next-solver/diagnostics/projection-trait-ref.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `T: Trait` is not satisfied
LL | let x: <T as Trait>::Assoc = ();
| ^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | fn test_poly<T: Trait>() {
| +++++++
diff --git a/tests/ui/traits/next-solver/dyn-incompatibility.stderr b/tests/ui/traits/next-solver/dyn-incompatibility.stderr
index a720797efc4b9..5bc5fd8cb5e8d 100644
--- a/tests/ui/traits/next-solver/dyn-incompatibility.stderr
+++ b/tests/ui/traits/next-solver/dyn-incompatibility.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `copy`
|
LL | fn copy<U: Setup + ?Sized>(from: &U::From) -> U::From {
| ^^^^^ required by this bound in `copy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
| +++++++++++++++++++
@@ -38,7 +38,7 @@ LL | copy::<dyn Setup<From=T>>(t)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `dyn Setup<From = T>`, the trait `Copy` is not implemented for `T`
|
= note: required because it appears within the type `dyn Setup<From = T>`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
| +++++++++++++++++++
diff --git a/tests/ui/traits/next-solver/global-cache-and-parallel-frontend.stderr b/tests/ui/traits/next-solver/global-cache-and-parallel-frontend.stderr
index 1f319cc6743bc..87689f2a7ffe4 100644
--- a/tests/ui/traits/next-solver/global-cache-and-parallel-frontend.stderr
+++ b/tests/ui/traits/next-solver/global-cache-and-parallel-frontend.stderr
@@ -14,7 +14,7 @@ LL | impl<T: Clone, U> PartialEq<U> for Struct<T>
note: required by a bound in `Eq`
--> $SRC_DIR/core/src/cmp.rs:LL:COL
= note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::clone::Clone`
|
LL | pub struct Struct<T: std::clone::Clone>(T);
| +++++++++++++++++++
diff --git a/tests/ui/traits/next-solver/issue-118950-root-region.stderr b/tests/ui/traits/next-solver/issue-118950-root-region.stderr
index 09162970d33da..523c92aa3b59b 100644
--- a/tests/ui/traits/next-solver/issue-118950-root-region.stderr
+++ b/tests/ui/traits/next-solver/issue-118950-root-region.stderr
@@ -32,7 +32,7 @@ error[E0277]: the trait bound `T: Overlap<for<'a> fn(Assoc<'a, T>)>` is not sati
LL | impl<T> Overlap<for<'a> fn(Assoc<'a, T>)> for T where Missing: Overlap<T> {}
| ^ the trait `Overlap<for<'a> fn(Assoc<'a, T>)>` is not implemented for `T`
|
-help: consider further restricting type parameter `T`
+help: consider further restricting type parameter `T` with trait `Overlap<for<'a> fn(Assoc<'a, T>)>`
|
LL | impl<T> Overlap<for<'a> fn(Assoc<'a, T>)> for T where Missing: Overlap<T>, T: Overlap<for<'a> fn(Assoc<'a, T>)> {}
| ++++++++++++++++++++++++++++++++++++++
diff --git a/tests/ui/tuple/builtin-fail.stderr b/tests/ui/tuple/builtin-fail.stderr
index cc295dabb1748..6130538d77e59 100644
--- a/tests/ui/tuple/builtin-fail.stderr
+++ b/tests/ui/tuple/builtin-fail.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `assert_is_tuple`
|
LL | fn assert_is_tuple<T: std::marker::Tuple + ?Sized>() {}
| ^^^^^^^^^^^^^^^^^^ required by this bound in `assert_is_tuple`
-help: consider restricting type parameter `T` but it is an `unstable` trait
+help: consider restricting type parameter `T` with unstable trait `std::marker::Tuple`
|
LL | fn from_param_env<T: std::marker::Tuple>() {
| ++++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr b/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
index 8f887a6ac68f9..802457426e034 100644
--- a/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
+++ b/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
@@ -14,7 +14,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn f<T: Clone>(t: T) -> X<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::clone::Clone`
|
LL | pub type X<T: std::clone::Clone> = impl Clone;
| +++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr b/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
index bca88b5fae10f..d421e24685e32 100644
--- a/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
+++ b/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Struct`
|
LL | struct Struct<V: Display>(Option<V>);
| ^^^^^^^ required by this bound in `Struct`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `std::fmt::Display`
|
LL | type Foo<T: Debug + std::fmt::Display> = (impl Debug, Struct<T>);
| +++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/future.stderr b/tests/ui/type-alias-impl-trait/future.stderr
index b20073fcdfcde..047ad164239c0 100644
--- a/tests/ui/type-alias-impl-trait/future.stderr
+++ b/tests/ui/type-alias-impl-trait/future.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `foo`
|
LL | fn foo<B: Bar>(bar: B) -> FooFuture<B> {
| ^^^ required by this bound in `foo`
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Bar`
|
LL | type FooFuture<B: Bar> = impl Future<Output = ()>;
| +++++
diff --git a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
index af6e6e1e66e8f..b03b58ca0134d 100644
--- a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
@@ -14,7 +14,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn two<T: Debug, U>(t: T, _: U) -> Two<T, U> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::fmt::Debug`
|
LL | type Two<T: std::fmt::Debug, U> = impl Debug;
| +++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
index a847bed93da79..97729076ae85c 100644
--- a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
@@ -14,7 +14,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn three<T, U: Debug>(_: T, u: U) -> Two<T, U> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `U`
+help: consider restricting type parameter `U` with trait `std::fmt::Debug`
|
LL | type Two<T, U: std::fmt::Debug> = impl Debug;
| +++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/generic_underconstrained.stderr b/tests/ui/type-alias-impl-trait/generic_underconstrained.stderr
index 88529b370f133..98f99cdbfbd65 100644
--- a/tests/ui/type-alias-impl-trait/generic_underconstrained.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_underconstrained.stderr
@@ -9,7 +9,7 @@ note: required by a bound on the type alias `Underconstrained`
|
LL | type Underconstrained<T: Trait> = impl Send;
| ^^^^^ required by this bound
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | fn underconstrain<T: Trait>(_: T) -> Underconstrained<T> {
| +++++++
@@ -30,7 +30,7 @@ note: required by a bound on the type alias `Underconstrained`
|
LL | type Underconstrained<T: Trait> = impl Send;
| ^^^^^ required by this bound
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | fn underconstrain<T: Trait>(_: T) -> Underconstrained<T> {
| +++++++
diff --git a/tests/ui/type-alias-impl-trait/generic_underconstrained2.stderr b/tests/ui/type-alias-impl-trait/generic_underconstrained2.stderr
index b3b9cbca96854..a1561cf41dddc 100644
--- a/tests/ui/type-alias-impl-trait/generic_underconstrained2.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_underconstrained2.stderr
@@ -9,7 +9,7 @@ note: required by a bound on the type alias `Underconstrained`
|
LL | type Underconstrained<T: std::fmt::Debug> = impl Send;
| ^^^^^^^^^^^^^^^ required by this bound
-help: consider restricting type parameter `U`
+help: consider restricting type parameter `U` with trait `std::fmt::Debug`
|
LL | fn underconstrained<U: std::fmt::Debug>(_: U) -> Underconstrained<U> {
| +++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound on the type alias `Underconstrained2`
|
LL | type Underconstrained2<T: std::fmt::Debug> = impl Send;
| ^^^^^^^^^^^^^^^ required by this bound
-help: consider restricting type parameter `V`
+help: consider restricting type parameter `V` with trait `std::fmt::Debug`
|
LL | fn underconstrained2<U, V: std::fmt::Debug>(_: U, _: V) -> Underconstrained2<V> {
| +++++++++++++++++
@@ -46,7 +46,7 @@ note: required by a bound on the type alias `Underconstrained`
|
LL | type Underconstrained<T: std::fmt::Debug> = impl Send;
| ^^^^^^^^^^^^^^^ required by this bound
-help: consider restricting type parameter `U`
+help: consider restricting type parameter `U` with trait `std::fmt::Debug`
|
LL | fn underconstrained<U: std::fmt::Debug>(_: U) -> Underconstrained<U> {
| +++++++++++++++++
@@ -67,7 +67,7 @@ note: required by a bound on the type alias `Underconstrained2`
|
LL | type Underconstrained2<T: std::fmt::Debug> = impl Send;
| ^^^^^^^^^^^^^^^ required by this bound
-help: consider restricting type parameter `V`
+help: consider restricting type parameter `V` with trait `std::fmt::Debug`
|
LL | fn underconstrained2<U, V: std::fmt::Debug>(_: U, _: V) -> Underconstrained2<V> {
| +++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/issue-52843.stderr b/tests/ui/type-alias-impl-trait/issue-52843.stderr
index a6bdddbc98c67..19ca31e2ab01a 100644
--- a/tests/ui/type-alias-impl-trait/issue-52843.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-52843.stderr
@@ -14,7 +14,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn foo<T: Default>(t: T) -> Foo<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::default::Default`
|
LL | type Foo<T: std::default::Default> = impl Default;
| +++++++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/issue-53092.stderr b/tests/ui/type-alias-impl-trait/issue-53092.stderr
index f04750866c762..3d8bdab57e61f 100644
--- a/tests/ui/type-alias-impl-trait/issue-53092.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-53092.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `make_bug`
|
LL | fn make_bug<T, U: From<T>>() -> Bug<T, U> {
| ^^^^^^^ required by this bound in `make_bug`
-help: consider restricting type parameter `U`
+help: consider restricting type parameter `U` with trait `std::convert::From<T>`
|
LL | pub type Bug<T, U: std::convert::From<T>> = impl Fn(T) -> U + Copy;
| +++++++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/issue-89686.stderr b/tests/ui/type-alias-impl-trait/issue-89686.stderr
index 91d71339a0848..6fa7e197c40c4 100644
--- a/tests/ui/type-alias-impl-trait/issue-89686.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-89686.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `T: Trait` is not satisfied
LL | async move { self.f().await }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | type G<'a, T: Trait> = impl Future<Output = ()>;
| +++++++
diff --git a/tests/ui/type-alias-impl-trait/issue-90400-1.stderr b/tests/ui/type-alias-impl-trait/issue-90400-1.stderr
index bc233a5321437..afdccd56a50f4 100644
--- a/tests/ui/type-alias-impl-trait/issue-90400-1.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-90400-1.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `<MyFoo as Foo>::foo`
|
LL | fn foo<B: Bar>(&self, bar: B) -> Self::FooFn<B> {
| ^^^ required by this bound in `<MyFoo as Foo>::foo`
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Bar`
|
LL | type FooFn<B: Bar> = impl FnOnce();
| +++++
diff --git a/tests/ui/type-alias-impl-trait/issue-90400-2.stderr b/tests/ui/type-alias-impl-trait/issue-90400-2.stderr
index 4a6a62bdf96dd..d4faa6e939259 100644
--- a/tests/ui/type-alias-impl-trait/issue-90400-2.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-90400-2.stderr
@@ -21,7 +21,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn foo<B: Bar>(&self, bar: B) -> Self::FooFn<B> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Bar`
|
LL | type FooFn<B: Bar> = impl Baz;
| +++++
diff --git a/tests/ui/type-alias-impl-trait/not_well_formed.stderr b/tests/ui/type-alias-impl-trait/not_well_formed.stderr
index a2944a1acb97a..e2fa9442323ae 100644
--- a/tests/ui/type-alias-impl-trait/not_well_formed.stderr
+++ b/tests/ui/type-alias-impl-trait/not_well_formed.stderr
@@ -4,7 +4,7 @@ error[E0220]: associated type `Assoc` not found for `V`
LL | type Foo<V> = impl Trait<V::Assoc>;
| ^^^^^ there is an associated type `Assoc` in the trait `TraitWithAssoc`
|
-help: consider restricting type parameter `V`
+help: consider restricting type parameter `V` with trait `TraitWithAssoc`
|
LL | type Foo<V: TraitWithAssoc> = impl Trait<V::Assoc>;
| ++++++++++++++++
@@ -16,7 +16,7 @@ LL | type Foo<V> = impl Trait<V::Assoc>;
| ^^^^^ there is an associated type `Assoc` in the trait `TraitWithAssoc`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider restricting type parameter `V`
+help: consider restricting type parameter `V` with trait `TraitWithAssoc`
|
LL | type Foo<V: TraitWithAssoc> = impl Trait<V::Assoc>;
| ++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/underconstrained_generic.stderr b/tests/ui/type-alias-impl-trait/underconstrained_generic.stderr
index 48cef847fbbff..e50949ed8f369 100644
--- a/tests/ui/type-alias-impl-trait/underconstrained_generic.stderr
+++ b/tests/ui/type-alias-impl-trait/underconstrained_generic.stderr
@@ -21,7 +21,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn _defining_use<T: Trait>() -> Converter<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | type Converter<T: Trait> = impl ProofForConversion<T>;
| +++++++
diff --git a/tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr b/tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr
index 47bea7bbe608c..9046a8a76b82b 100644
--- a/tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr
+++ b/tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `mop`
|
LL | fn mop<B: Bar>(bar: B) { bar.bar() }
| ^^^ required by this bound in `mop`
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Bar`
|
LL | type FooFn<B: Bar> = impl FnOnce(B);
| +++++
diff --git a/tests/ui/type-alias-impl-trait/wf_check_closures.stderr b/tests/ui/type-alias-impl-trait/wf_check_closures.stderr
index 09a42f73490a0..4156f0ca96aea 100644
--- a/tests/ui/type-alias-impl-trait/wf_check_closures.stderr
+++ b/tests/ui/type-alias-impl-trait/wf_check_closures.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `foo`
|
LL | fn foo<B: Bar>(bar: B) -> FooFn<B> {
| ^^^ required by this bound in `foo`
-help: consider restricting type parameter `B`
+help: consider restricting type parameter `B` with trait `Bar`
|
LL | type FooFn<B: Bar> = impl FnOnce();
| +++++
diff --git a/tests/ui/type-alias/unresolved-assoc-ty-suggest-trait.lazy.stderr b/tests/ui/type-alias/unresolved-assoc-ty-suggest-trait.lazy.stderr
index 96179a7b48466..a3935efcd7f2e 100644
--- a/tests/ui/type-alias/unresolved-assoc-ty-suggest-trait.lazy.stderr
+++ b/tests/ui/type-alias/unresolved-assoc-ty-suggest-trait.lazy.stderr
@@ -4,7 +4,7 @@ error[E0220]: associated type `Assoc` not found for `T`
LL | type AssocOf<T> = T::Assoc;
| ^^^^^ there is an associated type `Assoc` in the trait `Trait`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | type AssocOf<T: Trait> = T::Assoc;
| +++++++
@@ -15,7 +15,7 @@ error[E0220]: associated type `Assok` not found for `T`
LL | type AssokOf<T> = T::Assok;
| ^^^^^ there is a similarly named associated type `Assoc` in the trait `Trait`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | type AssokOf<T: Trait> = T::Assok;
| +++++++
@@ -30,7 +30,7 @@ error[E0220]: associated type `Proj` not found for `T`
LL | type ProjOf<T> = T::Proj;
| ^^^^ there is an associated type `Proj` in the trait `Parametrized`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `Parametrized</* 'a, T, N */>`
|
LL | type ProjOf<T: Parametrized</* 'a, T, N */>> = T::Proj;
| ++++++++++++++++++++++++++++++
diff --git a/tests/ui/type/type-check-defaults.stderr b/tests/ui/type/type-check-defaults.stderr
index 9c48250612971..87801e5cc9e1e 100644
--- a/tests/ui/type/type-check-defaults.stderr
+++ b/tests/ui/type/type-check-defaults.stderr
@@ -53,7 +53,7 @@ note: required by a bound in `Super`
|
LL | trait Super<T: Copy> { }
| ^^^^ required by this bound in `Super`
-help: consider further restricting type parameter `T`
+help: consider further restricting type parameter `T` with trait `std::marker::Copy`
|
LL | trait Base<T = String>: Super<T> where T: std::marker::Copy { }
| ++++++++++++++++++++++++++
diff --git a/tests/ui/type/type-check/missing_trait_impl.stderr b/tests/ui/type/type-check/missing_trait_impl.stderr
index 2b58cd4180bd3..aa454cce07fd4 100644
--- a/tests/ui/type/type-check/missing_trait_impl.stderr
+++ b/tests/ui/type/type-check/missing_trait_impl.stderr
@@ -6,7 +6,7 @@ LL | let z = x + y;
| |
| T
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::ops::Add`
|
LL | fn foo<T: std::ops::Add>(x: T, y: T) {
| +++++++++++++++
@@ -19,7 +19,7 @@ LL | x += x;
| |
| cannot use `+=` on type `T`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::ops::AddAssign`
|
LL | fn bar<T: std::ops::AddAssign>(x: T) {
| +++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0600]: cannot apply unary operator `-` to type `T`
LL | let y = -x;
| ^^ cannot apply unary operator `-`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::ops::Neg`
|
LL | fn baz<T: std::ops::Neg>(x: T) {
| +++++++++++++++
@@ -41,7 +41,7 @@ error[E0600]: cannot apply unary operator `!` to type `T`
LL | let y = !x;
| ^^ cannot apply unary operator `!`
|
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::ops::Not`
|
LL | fn baz<T: std::ops::Not>(x: T) {
| +++++++++++++++
diff --git a/tests/ui/typeck/bad-index-due-to-nested.stderr b/tests/ui/typeck/bad-index-due-to-nested.stderr
index bd7fd0392c378..4492a21c3ccaf 100644
--- a/tests/ui/typeck/bad-index-due-to-nested.stderr
+++ b/tests/ui/typeck/bad-index-due-to-nested.stderr
@@ -12,7 +12,7 @@ LL | impl<K, V> Index<&K> for HashMap<K, V>
LL | where
LL | K: Hash,
| ---- unsatisfied trait bound introduced here
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `std::hash::Hash`
|
LL | fn index<'a, K: std::hash::Hash, V>(map: &'a HashMap<K, V>, k: K) -> &'a V {
| +++++++++++++++++
@@ -31,7 +31,7 @@ LL | impl<K, V> Index<&K> for HashMap<K, V>
...
LL | V: Copy,
| ---- unsatisfied trait bound introduced here
-help: consider restricting type parameter `V`
+help: consider restricting type parameter `V` with trait `std::marker::Copy`
|
LL | fn index<'a, K, V: std::marker::Copy>(map: &'a HashMap<K, V>, k: K) -> &'a V {
| +++++++++++++++++++
diff --git a/tests/ui/typeck/issue-90164.stderr b/tests/ui/typeck/issue-90164.stderr
index 43e96e1adc6bd..61c2ae3e0ef84 100644
--- a/tests/ui/typeck/issue-90164.stderr
+++ b/tests/ui/typeck/issue-90164.stderr
@@ -13,7 +13,7 @@ note: required by a bound in `copy`
|
LL | fn copy<R: Unpin, W>(_: R, _: W) {}
| ^^^^^ required by this bound in `copy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Unpin`
|
LL | fn f<T: std::marker::Unpin>(r: T) {
| ++++++++++++++++++++
diff --git a/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr b/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
index 537ae6b2b5f66..2e52d0c13d906 100644
--- a/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
+++ b/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T:Send>() {
| ^^^^ required by this bound in `is_send`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Send`
|
LL | fn foo<T: std::marker::Send>() {
| +++++++++++++++++++
diff --git a/tests/ui/union/issue-81199.stderr b/tests/ui/union/issue-81199.stderr
index 0dd894beb2a46..d815e67d18621 100644
--- a/tests/ui/union/issue-81199.stderr
+++ b/tests/ui/union/issue-81199.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `PtrComponents`
|
LL | struct PtrComponents<T: Pointee + ?Sized> {
| ^^^^^^^ required by this bound in `PtrComponents`
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Pointee`
|
LL | union PtrRepr<T: ?Sized + Pointee> {
| +++++++++
diff --git a/tests/ui/unop/unop-move-semantics.stderr b/tests/ui/unop/unop-move-semantics.stderr
index 0ae918d434a0f..89483b7b9cde3 100644
--- a/tests/ui/unop/unop-move-semantics.stderr
+++ b/tests/ui/unop/unop-move-semantics.stderr
@@ -15,7 +15,7 @@ help: consider cloning the value if the performance cost is acceptable
|
LL | !x.clone();
| ++++++++
-help: consider further restricting this bound
+help: consider further restricting this bound with trait `Copy`
|
LL | fn move_then_borrow<T: Not<Output=T> + Clone + Copy>(x: T) {
| ++++++
diff --git a/tests/ui/wf/issue-96810.stderr b/tests/ui/wf/issue-96810.stderr
index 622d72f791e2e..3f87d3e0786fb 100644
--- a/tests/ui/wf/issue-96810.stderr
+++ b/tests/ui/wf/issue-96810.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `S`
|
LL | struct S<T: Tr>(T::Assoc);
| ^^ required by this bound in `S`
-help: consider restricting type parameter `K`
+help: consider restricting type parameter `K` with trait `Tr`
|
LL | struct Hoge<K: Tr> {
| ++++
diff --git a/tests/ui/wf/wf-enum-bound.stderr b/tests/ui/wf/wf-enum-bound.stderr
index 78b5c6ec20eb4..66b1f294511b3 100644
--- a/tests/ui/wf/wf-enum-bound.stderr
+++ b/tests/ui/wf/wf-enum-bound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U`
+help: consider further restricting type parameter `U` with trait `std::marker::Copy`
|
LL | where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-enum-fields-struct-variant.stderr b/tests/ui/wf/wf-enum-fields-struct-variant.stderr
index 2f2c1c2d2665c..ff5874ac3e4bc 100644
--- a/tests/ui/wf/wf-enum-fields-struct-variant.stderr
+++ b/tests/ui/wf/wf-enum-fields-struct-variant.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `IsCopy`
|
LL | struct IsCopy<T:Copy> {
| ^^^^ required by this bound in `IsCopy`
-help: consider restricting type parameter `A`
+help: consider restricting type parameter `A` with trait `std::marker::Copy`
|
LL | enum AnotherEnum<A: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-enum-fields.stderr b/tests/ui/wf/wf-enum-fields.stderr
index a5feaadfc7587..b6bbe6c9bbc54 100644
--- a/tests/ui/wf/wf-enum-fields.stderr
+++ b/tests/ui/wf/wf-enum-fields.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `IsCopy`
|
LL | struct IsCopy<T:Copy> {
| ^^^^ required by this bound in `IsCopy`
-help: consider restricting type parameter `A`
+help: consider restricting type parameter `A` with trait `std::marker::Copy`
|
LL | enum SomeEnum<A: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-fn-where-clause.stderr b/tests/ui/wf/wf-fn-where-clause.stderr
index fbfe42ac62477..940bcbc93fd53 100644
--- a/tests/ui/wf/wf-fn-where-clause.stderr
+++ b/tests/ui/wf/wf-fn-where-clause.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U`
+help: consider further restricting type parameter `U` with trait `std::marker::Copy`
|
LL | fn foo<T,U>() where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-impl-associated-type-trait.stderr b/tests/ui/wf/wf-impl-associated-type-trait.stderr
index 09e255bead025..47962c75d69d2 100644
--- a/tests/ui/wf/wf-impl-associated-type-trait.stderr
+++ b/tests/ui/wf/wf-impl-associated-type-trait.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MySet`
|
LL | pub struct MySet<T:MyHash> {
| ^^^^^^ required by this bound in `MySet`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `MyHash`
|
LL | impl<T: MyHash> Foo for T {
| ++++++++
diff --git a/tests/ui/wf/wf-in-fn-arg.stderr b/tests/ui/wf/wf-in-fn-arg.stderr
index 8f22edd17a100..2cf51987e45fe 100644
--- a/tests/ui/wf/wf-in-fn-arg.stderr
+++ b/tests/ui/wf/wf-in-fn-arg.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | fn bar<T: std::marker::Copy>(_: &MustBeCopy<T>)
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-ret.stderr b/tests/ui/wf/wf-in-fn-ret.stderr
index 1ae49a348cc69..30c29270e2194 100644
--- a/tests/ui/wf/wf-in-fn-ret.stderr
+++ b/tests/ui/wf/wf-in-fn-ret.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T: Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | fn bar<T: std::marker::Copy>() -> MustBeCopy<T>
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-type-arg.stderr b/tests/ui/wf/wf-in-fn-type-arg.stderr
index 17594c813daa7..7ceb8ffa365bd 100644
--- a/tests/ui/wf/wf-in-fn-type-arg.stderr
+++ b/tests/ui/wf/wf-in-fn-type-arg.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | struct Bar<T: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-type-ret.stderr b/tests/ui/wf/wf-in-fn-type-ret.stderr
index fac535a112659..2773f9b72822f 100644
--- a/tests/ui/wf/wf-in-fn-type-ret.stderr
+++ b/tests/ui/wf/wf-in-fn-type-ret.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | struct Foo<T: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-where-clause.stderr b/tests/ui/wf/wf-in-fn-where-clause.stderr
index 4c556d3d77de3..6ad9d7ab92cc8 100644
--- a/tests/ui/wf/wf-in-fn-where-clause.stderr
+++ b/tests/ui/wf/wf-in-fn-where-clause.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | trait MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider further restricting type parameter `U`
+help: consider further restricting type parameter `U` with trait `std::marker::Copy`
|
LL | where T: MustBeCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-obj-type-trait.stderr b/tests/ui/wf/wf-in-obj-type-trait.stderr
index b96f56a12a54c..997c49a7c75a4 100644
--- a/tests/ui/wf/wf-in-obj-type-trait.stderr
+++ b/tests/ui/wf/wf-in-obj-type-trait.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | struct Bar<T: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr b/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
index 4cfbec12b6e41..db37b05886c02 100644
--- a/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
+++ b/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider restricting type parameter `U`
+help: consider restricting type parameter `U` with trait `std::marker::Copy`
|
LL | impl<T,U: std::marker::Copy> Foo<T,U> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-inherent-impl-where-clause.stderr b/tests/ui/wf/wf-inherent-impl-where-clause.stderr
index bdc1ee3e0e21c..4e8886eb60406 100644
--- a/tests/ui/wf/wf-inherent-impl-where-clause.stderr
+++ b/tests/ui/wf/wf-inherent-impl-where-clause.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U`
+help: consider further restricting type parameter `U` with trait `std::marker::Copy`
|
LL | impl<T,U> Foo<T,U> where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-struct-bound.stderr b/tests/ui/wf/wf-struct-bound.stderr
index 4ac7f4634e462..87cbe7dd51887 100644
--- a/tests/ui/wf/wf-struct-bound.stderr
+++ b/tests/ui/wf/wf-struct-bound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U`
+help: consider further restricting type parameter `U` with trait `std::marker::Copy`
|
LL | where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-struct-field.stderr b/tests/ui/wf/wf-struct-field.stderr
index 241ced3c2dbd8..ae63e85972ba3 100644
--- a/tests/ui/wf/wf-struct-field.stderr
+++ b/tests/ui/wf/wf-struct-field.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `IsCopy`
|
LL | struct IsCopy<T:Copy> {
| ^^^^ required by this bound in `IsCopy`
-help: consider restricting type parameter `A`
+help: consider restricting type parameter `A` with trait `std::marker::Copy`
|
LL | struct SomeStruct<A: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-trait-associated-type-bound.stderr b/tests/ui/wf/wf-trait-associated-type-bound.stderr
index 4ea895a9b0396..25a0d40e8641d 100644
--- a/tests/ui/wf/wf-trait-associated-type-bound.stderr
+++ b/tests/ui/wf/wf-trait-associated-type-bound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | trait SomeTrait<T: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-trait-bound.stderr b/tests/ui/wf/wf-trait-bound.stderr
index 5845d05b38e67..b8ad005ef7a4b 100644
--- a/tests/ui/wf/wf-trait-bound.stderr
+++ b/tests/ui/wf/wf-trait-bound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U`
+help: consider further restricting type parameter `U` with trait `std::marker::Copy`
|
LL | where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-trait-superbound.stderr b/tests/ui/wf/wf-trait-superbound.stderr
index 3c05065e57f91..3d84cd81774c0 100644
--- a/tests/ui/wf/wf-trait-superbound.stderr
+++ b/tests/ui/wf/wf-trait-superbound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | trait SomeTrait<T: std::marker::Copy>: ExtraCopy<T> {
| +++++++++++++++++++
diff --git a/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr b/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
index 2612cefef28c1..b3abbaa0594a7 100644
--- a/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
+++ b/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `require_copy`
|
LL | fn require_copy<T: Copy>(x: T) {}
| ^^^^ required by this bound in `require_copy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> Foo<T> {
| +++++++++++++++++++
diff --git a/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr b/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
index 090df26a39e10..0bfd0537773c4 100644
--- a/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
+++ b/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `require_copy`
|
LL | fn require_copy<T: Copy>(x: T) {}
| ^^^^ required by this bound in `require_copy`
-help: consider restricting type parameter `T`
+help: consider restricting type parameter `T` with trait `std::marker::Copy`
|
LL | impl<T: std::marker::Copy> Foo<T> for Bar<T> {
| +++++++++++++++++++
From 568b0ac624553150330f1cc3bbff9b99e5d358a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Thu, 28 Nov 2024 19:31:37 +0000
Subject: [PATCH 03/10] Add test for lack of suggestion in stable
This test will break when `Step` gets stabilized, but punt until then.
---
compiler/rustc_middle/src/ty/diagnostics.rs | 4 ++--
.../missing-bound.rs | 4 ++++
.../missing-unstable-trait-bound/rmake.rs | 22 +++++++++++++++++++
.../trait-bounds/unstable-trait-suggestion.rs | 6 ++++-
.../unstable-trait-suggestion.stderr | 19 +++++++++++++---
5 files changed, 49 insertions(+), 6 deletions(-)
create mode 100644 tests/run-make/missing-unstable-trait-bound/missing-bound.rs
create mode 100644 tests/run-make/missing-unstable-trait-bound/rmake.rs
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index a8500398082fb..d34fb0945bb67 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -488,7 +488,7 @@ pub fn suggest_constraining_type_params<'a>(
.into_iter()
.filter(|(span, _, _, _)| !span.in_derive_expansion())
.collect::<Vec<_>>();
-
+ let suggested = !suggestions.is_empty();
if suggestions.len() == 1 {
let (span, constraint, suggestion, msg) = suggestions.pop().unwrap();
let post = format!(
@@ -524,7 +524,7 @@ pub fn suggest_constraining_type_params<'a>(
);
}
- true
+ suggested
}
/// Collect al types that have an implicit `'static` obligation that we could suggest `'_` for.
diff --git a/tests/run-make/missing-unstable-trait-bound/missing-bound.rs b/tests/run-make/missing-unstable-trait-bound/missing-bound.rs
new file mode 100644
index 0000000000000..65d0745f49440
--- /dev/null
+++ b/tests/run-make/missing-unstable-trait-bound/missing-bound.rs
@@ -0,0 +1,4 @@
+pub fn baz<T>(t: std::ops::Range<T>) {
+ for _ in t {}
+}
+fn main() {}
diff --git a/tests/run-make/missing-unstable-trait-bound/rmake.rs b/tests/run-make/missing-unstable-trait-bound/rmake.rs
new file mode 100644
index 0000000000000..1e0cb1336a4a8
--- /dev/null
+++ b/tests/run-make/missing-unstable-trait-bound/rmake.rs
@@ -0,0 +1,22 @@
+//@ only-linux
+//@ ignore-wasm32
+//@ ignore-wasm64
+// ignore-tidy-linelength
+
+// Ensure that on stable we don't suggest restricting with an unsafe trait and we continue
+// mentioning the rest of the obligation chain.
+
+use run_make_support::{rust_lib_name, rustc};
+
+fn main() {
+ rustc()
+ .env("RUSTC_BOOTSTRAP", "-1")
+ .input("missing-bound.rs")
+ .run_fail()
+ .assert_stderr_not_contains("help: consider restricting type parameter `T`")
+ .assert_stderr_contains(
+ r#"
+ = note: required for `std::ops::Range<T>` to implement `Iterator`
+ = note: required for `std::ops::Range<T>` to implement `IntoIterator`"#,
+ );
+}
diff --git a/tests/ui/trait-bounds/unstable-trait-suggestion.rs b/tests/ui/trait-bounds/unstable-trait-suggestion.rs
index c49e2a3403326..ba96b4f3f97f9 100644
--- a/tests/ui/trait-bounds/unstable-trait-suggestion.rs
+++ b/tests/ui/trait-bounds/unstable-trait-suggestion.rs
@@ -9,7 +9,11 @@ pub trait Unstable {}
fn foo<T: Unstable>(_: T) {}
#[stable(feature = "unit_test", since = "1.0.0")]
-pub fn demo<T>(t: T) { //~ HELP consider restricting type parameter `T` with unstable trait `Unstable`
+pub fn bar<T>(t: T) { //~ HELP consider restricting type parameter `T` with unstable trait `Unstable`
foo(t) //~ ERROR E0277
}
+#[stable(feature = "unit_test", since = "1.0.0")]
+pub fn baz<T>(t: std::ops::Range<T>) { //~ HELP consider restricting type parameter `T` with unstable trait
+ for _ in t {} //~ ERROR E0277
+}
fn main() {}
diff --git a/tests/ui/trait-bounds/unstable-trait-suggestion.stderr b/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
index a326965b683d5..fa8e428aa1fec 100644
--- a/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
+++ b/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
@@ -13,9 +13,22 @@ LL | fn foo<T: Unstable>(_: T) {}
| ^^^^^^^^ required by this bound in `foo`
help: consider restricting type parameter `T` with unstable trait `Unstable`
|
-LL | pub fn demo<T: Unstable>(t: T) {
- | ++++++++++
+LL | pub fn bar<T: Unstable>(t: T) {
+ | ++++++++++
-error: aborting due to 1 previous error
+error[E0277]: the trait bound `T: Step` is not satisfied
+ --> $DIR/unstable-trait-suggestion.rs:17:14
+ |
+LL | for _ in t {}
+ | ^ the trait `Step` is not implemented for `T`
+ |
+ = note: required for `std::ops::Range<T>` to implement `Iterator`
+ = note: required for `std::ops::Range<T>` to implement `IntoIterator`
+help: consider restricting type parameter `T` with unstable trait `std::iter::Step`
+ |
+LL | pub fn baz<T: std::iter::Step>(t: std::ops::Range<T>) {
+ | +++++++++++++++++
+
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.
From 3f2a63a68bbf4e84f7e409659bb64bdd75db39e5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Thu, 28 Nov 2024 20:22:46 +0000
Subject: [PATCH 04/10] Use trait name instead of full constraint in suggestion
message
```
help: consider restricting type parameter `T` with traits `Copy` and `Trait`
|
LL | fn duplicate_custom<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) {
| ++++++++++++++
```
```
help: consider restricting type parameter `V` with trait `Copy`
|
LL | fn index<'a, K, V: std::marker::Copy>(map: &'a HashMap<K, V>, k: K) -> &'a V {
| +++++++++++++++++++
```
---
compiler/rustc_middle/src/ty/diagnostics.rs | 84 ++++++++++++++-----
...ns-in-super-trait-bound-unsatisfied.stderr | 4 +-
.../defaults-suitability.current.stderr | 4 +-
.../defaults-suitability.next.stderr | 4 +-
.../hr-associated-type-bound-param-6.stderr | 2 +-
.../issue-27675-unchecked-bounds.stderr | 2 +-
.../issue-43784-associated-type.stderr | 2 +-
tests/ui/async-await/issue-70818.stderr | 2 +-
tests/ui/async-await/issue-86507.stderr | 2 +-
tests/ui/binop/issue-93927.stderr | 2 +-
...builtin-superkinds-double-superkind.stderr | 4 +-
.../builtin-superkinds-in-metadata.stderr | 2 +-
...builtin-superkinds-typaram-not-send.stderr | 2 +-
...ds-cant-promote-superkind-in-struct.stderr | 4 +-
.../ui/closures/closure-bounds-subtype.stderr | 2 +-
.../issues/issue-61336-2.stderr | 2 +-
.../const-generics/issues/issue-61336.stderr | 2 +-
.../ct-var-in-collect_all_mismatches.stderr | 2 +-
.../dropck/explicit-drop-bounds.bad1.stderr | 4 +-
.../dropck/explicit-drop-bounds.bad2.stderr | 4 +-
.../blame-trait-error.stderr | 4 +-
.../generic-associated-types-where.stderr | 2 +-
.../impl_bounds.stderr | 4 +-
.../issue-68641-check-gat-bounds.stderr | 2 +-
.../issue-68642-broken-llvm-ir.stderr | 2 +-
.../issue-68643-broken-mir.stderr | 2 +-
.../issue-68644-codegen-selection.stderr | 2 +-
.../issue-68645-codegen-fulfillment.stderr | 2 +-
.../issue-74824.current.stderr | 2 +-
.../issue-74824.next.stderr | 2 +-
.../missing-bounds.stderr | 2 +-
.../structually-relate-aliases.stderr | 2 +-
...igher-ranker-supertraits-transitive.stderr | 2 +-
.../normalize-under-binder/issue-85455.stderr | 4 +-
...-predicate-entailment-error.current.stderr | 10 +--
tests/ui/impl-trait/issue-55872-1.stderr | 4 +-
tests/ui/issues/issue-6738.stderr | 2 +-
.../ui/kindck/kindck-impl-type-params.stderr | 8 +-
...rust-call-abi-not-a-tuple-ice-81974.stderr | 10 +--
.../unsatisfied-bounds-type-alias-body.stderr | 2 +-
.../methods/filter-relevant-fn-bounds.stderr | 8 +-
.../mir/validate/validate-unsize-cast.stderr | 2 +-
.../missing-trait-bound-for-op.stderr | 2 +-
...use_of_moved_value_copy_suggestions.stderr | 10 +--
tests/ui/phantom-auto-trait.stderr | 4 +-
...-implied-bounds-projection-gap-hr-1.stderr | 4 +-
...fault-generic-associated-type-bound.stderr | 2 +-
.../defaultimpl/specialization-wfcheck.stderr | 2 +-
tests/ui/specialization/issue-33017.stderr | 2 +-
.../min_specialization/issue-79224.stderr | 8 +-
tests/ui/suggestions/bound-suggestions.stderr | 12 +--
.../ui/suggestions/derive-clone-for-eq.stderr | 2 +-
.../derive-macro-missing-bounds.stderr | 8 +-
tests/ui/suggestions/issue-97677.stderr | 2 +-
...missing-bound-in-derive-copy-impl-2.stderr | 8 +-
...missing-bound-in-derive-copy-impl-3.stderr | 6 +-
.../missing-bound-in-derive-copy-impl.stderr | 14 ++--
...missing-bound-in-manual-copy-impl-2.stderr | 2 +-
.../suggestions/restrict-type-argument.stderr | 12 +--
.../trait-impl-bound-suggestions.stderr | 8 +-
.../unstable-trait-suggestion.stderr | 2 +-
.../ui/traits/bad-method-typaram-kind.stderr | 2 +-
.../inductive-overflow/two-traits.stderr | 2 +-
.../repeated-supertrait-ambig.stderr | 4 +-
tests/ui/traits/issue-43784-supertrait.stderr | 2 +-
.../next-solver/dyn-incompatibility.stderr | 4 +-
.../global-cache-and-parallel-frontend.stderr | 2 +-
tests/ui/tuple/builtin-fail.stderr | 2 +-
.../bounds-are-checked-2.stderr | 2 +-
.../bounds-are-checked3.stderr | 2 +-
.../generic_duplicate_param_use2.stderr | 2 +-
.../generic_duplicate_param_use4.stderr | 2 +-
.../generic_underconstrained2.stderr | 8 +-
.../type-alias-impl-trait/issue-52843.stderr | 2 +-
.../type-alias-impl-trait/issue-53092.stderr | 2 +-
tests/ui/type/type-check-defaults.stderr | 2 +-
.../type/type-check/missing_trait_impl.stderr | 8 +-
.../ui/typeck/bad-index-due-to-nested.stderr | 4 +-
tests/ui/typeck/issue-90164.stderr | 2 +-
...ypeck-default-trait-impl-send-param.stderr | 2 +-
tests/ui/wf/wf-enum-bound.stderr | 2 +-
.../wf/wf-enum-fields-struct-variant.stderr | 2 +-
tests/ui/wf/wf-enum-fields.stderr | 2 +-
tests/ui/wf/wf-fn-where-clause.stderr | 2 +-
tests/ui/wf/wf-in-fn-arg.stderr | 2 +-
tests/ui/wf/wf-in-fn-ret.stderr | 2 +-
tests/ui/wf/wf-in-fn-type-arg.stderr | 2 +-
tests/ui/wf/wf-in-fn-type-ret.stderr | 2 +-
tests/ui/wf/wf-in-fn-where-clause.stderr | 2 +-
tests/ui/wf/wf-in-obj-type-trait.stderr | 2 +-
...f-inherent-impl-method-where-clause.stderr | 2 +-
.../wf/wf-inherent-impl-where-clause.stderr | 2 +-
tests/ui/wf/wf-struct-bound.stderr | 2 +-
tests/ui/wf/wf-struct-field.stderr | 2 +-
.../wf/wf-trait-associated-type-bound.stderr | 2 +-
tests/ui/wf/wf-trait-bound.stderr | 2 +-
tests/ui/wf/wf-trait-superbound.stderr | 2 +-
...traints-are-local-for-inherent-impl.stderr | 2 +-
...onstraints-are-local-for-trait-impl.stderr | 2 +-
99 files changed, 229 insertions(+), 191 deletions(-)
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index d34fb0945bb67..5baf47436fc93 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -4,7 +4,9 @@ use std::fmt::Write;
use std::ops::ControlFlow;
use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::{Applicability, Diag, DiagArgValue, IntoDiagArg, into_diag_arg_using_display};
+use rustc_errors::{
+ Applicability, Diag, DiagArgValue, IntoDiagArg, into_diag_arg_using_display, pluralize,
+};
use rustc_hir::def::DefKind;
use rustc_hir::def_id::DefId;
use rustc_hir::{self as hir, LangItem, PredicateOrigin, WherePredicateKind};
@@ -288,7 +290,11 @@ pub fn suggest_constraining_type_params<'a>(
None => true,
};
if stable || tcx.sess.is_nightly_build() {
- grouped.entry(param_name).or_insert(Vec::new()).push((constraint, def_id));
+ grouped.entry(param_name).or_insert(Vec::new()).push((
+ constraint,
+ def_id,
+ if stable { "" } else { "unstable " },
+ ));
if !stable {
unstable_suggestion = true;
}
@@ -303,10 +309,10 @@ pub fn suggest_constraining_type_params<'a>(
let Some(param) = param else { return false };
{
- let mut sized_constraints = constraints.extract_if(|(_, def_id)| {
+ let mut sized_constraints = constraints.extract_if(|(_, def_id, _)| {
def_id.is_some_and(|def_id| tcx.is_lang_item(def_id, LangItem::Sized))
});
- if let Some((_, def_id)) = sized_constraints.next() {
+ if let Some((_, def_id, _)) = sized_constraints.next() {
applicability = Applicability::MaybeIncorrect;
err.span_label(param.span, "this type parameter needs to be `Sized`");
@@ -325,15 +331,52 @@ pub fn suggest_constraining_type_params<'a>(
.collect();
constraints
- .retain(|(_, def_id)| def_id.map_or(true, |def| !bound_trait_defs.contains(&def)));
+ .retain(|(_, def_id, _)| def_id.map_or(true, |def| !bound_trait_defs.contains(&def)));
if constraints.is_empty() {
continue;
}
- let mut constraint = constraints.iter().map(|&(c, _)| c).collect::<Vec<_>>();
+ let mut constraint = constraints.iter().map(|&(c, _, _)| c).collect::<Vec<_>>();
constraint.sort();
constraint.dedup();
+ let all_stable = constraints.iter().all(|&(_, _, stable)| stable.is_empty());
+ let all_unstable = constraints.iter().all(|&(_, _, stable)| !stable.is_empty());
+ let post = if all_stable || all_unstable {
+ // Don't redundantly say "trait `X`, trait `Y`", instead "traits `X` and `Y`"
+ let mut trait_names = constraints
+ .iter()
+ .map(|&(c, def_id, _)| match def_id {
+ None => format!("`{c}`"),
+ Some(def_id) => format!("`{}`", tcx.item_name(def_id)),
+ })
+ .collect::<Vec<_>>();
+ trait_names.sort();
+ trait_names.dedup();
+ let n = trait_names.len();
+ let stable = if all_stable { "" } else { "unstable " };
+ format!("{stable}trait{} {}", pluralize!(n), match &trait_names[..] {
+ [t] => t.to_string(),
+ [ts @ .., last] => format!("{} and {last}", ts.join(", ")),
+ [] => return false,
+ },)
+ } else {
+ // We're more explicit when there's a mix of stable and unstable traits.
+ let mut trait_names = constraints
+ .iter()
+ .map(|&(c, def_id, stable)| match def_id {
+ None => format!("{stable}trait `{c}`"),
+ Some(def_id) => format!("{stable}trait `{}`", tcx.item_name(def_id)),
+ })
+ .collect::<Vec<_>>();
+ trait_names.sort();
+ trait_names.dedup();
+ match &trait_names[..] {
+ [t] => t.to_string(),
+ [ts @ .., last] => format!("{} and {last}", ts.join(", ")),
+ [] => return false,
+ }
+ };
let constraint = constraint.join(" + ");
let mut suggest_restrict = |span, bound_list_non_empty, open_paren_sp| {
let suggestion = if span_to_replace.is_some() {
@@ -351,18 +394,18 @@ pub fn suggest_constraining_type_params<'a>(
if let Some(open_paren_sp) = open_paren_sp {
suggestions.push((
open_paren_sp,
- constraint.clone(),
+ post.clone(),
"(".to_string(),
RestrictBoundFurther,
));
suggestions.push((
span,
- constraint.clone(),
+ post.clone(),
format!("){suggestion}"),
RestrictBoundFurther,
));
} else {
- suggestions.push((span, constraint.clone(), suggestion, RestrictBoundFurther));
+ suggestions.push((span, post.clone(), suggestion, RestrictBoundFurther));
}
};
@@ -420,8 +463,8 @@ pub fn suggest_constraining_type_params<'a>(
// - insert: `, X: Bar`
suggestions.push((
generics.tail_span_for_predicate_suggestion(),
- constraint.clone(),
- constraints.iter().fold(String::new(), |mut string, &(constraint, _)| {
+ post,
+ constraints.iter().fold(String::new(), |mut string, &(constraint, _, _)| {
write!(string, ", {param_name}: {constraint}").unwrap();
string
}),
@@ -450,7 +493,7 @@ pub fn suggest_constraining_type_params<'a>(
// default (`<T=Foo>`), so we suggest adding `where T: Bar`.
suggestions.push((
generics.tail_span_for_predicate_suggestion(),
- constraint.clone(),
+ post,
format!("{where_prefix} {param_name}: {constraint}"),
SuggestChangingConstraintsMessage::RestrictTypeFurther { ty: param_name },
));
@@ -464,7 +507,7 @@ pub fn suggest_constraining_type_params<'a>(
if let Some(colon_span) = param.colon_span {
suggestions.push((
colon_span.shrink_to_hi(),
- constraint.clone(),
+ post,
format!(" {constraint}"),
SuggestChangingConstraintsMessage::RestrictType { ty: param_name },
));
@@ -477,7 +520,7 @@ pub fn suggest_constraining_type_params<'a>(
// - help: consider restricting this type parameter with `T: Foo`
suggestions.push((
param.span.shrink_to_hi(),
- constraint.clone(),
+ post,
format!(": {constraint}"),
SuggestChangingConstraintsMessage::RestrictType { ty: param_name },
));
@@ -490,21 +533,16 @@ pub fn suggest_constraining_type_params<'a>(
.collect::<Vec<_>>();
let suggested = !suggestions.is_empty();
if suggestions.len() == 1 {
- let (span, constraint, suggestion, msg) = suggestions.pop().unwrap();
- let post = format!(
- " with {}trait{} `{constraint}`",
- if unstable_suggestion { "unstable " } else { "" },
- if constraint.contains('+') { "s" } else { "" },
- );
+ let (span, post, suggestion, msg) = suggestions.pop().unwrap();
let msg = match msg {
SuggestChangingConstraintsMessage::RestrictBoundFurther => {
- format!("consider further restricting this bound{post}")
+ format!("consider further restricting this bound with {post}")
}
SuggestChangingConstraintsMessage::RestrictType { ty } => {
- format!("consider restricting type parameter `{ty}`{post}")
+ format!("consider restricting type parameter `{ty}` with {post}")
}
SuggestChangingConstraintsMessage::RestrictTypeFurther { ty } => {
- format!("consider further restricting type parameter `{ty}`{post}")
+ format!("consider further restricting type parameter `{ty}` with {post}")
}
SuggestChangingConstraintsMessage::RemoveMaybeUnsized => {
format!("consider removing the `?Sized` bound to make the type parameter `Sized`")
diff --git a/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr b/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
index 4044e124c8be1..75050e65b7e68 100644
--- a/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
+++ b/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `C: Bar<5>` is not satisfied
LL | pub struct Structure<C: Tec> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bar<5>` is not implemented for `C`
|
-help: consider further restricting this bound with trait `Bar<5>`
+help: consider further restricting this bound with trait `Bar`
|
LL | pub struct Structure<C: Tec + Bar<5>> {
| ++++++++
@@ -15,7 +15,7 @@ error[E0277]: the trait bound `C: Bar<5>` is not satisfied
LL | _field: C::BarType,
| ^^^^^^^^^^ the trait `Bar<5>` is not implemented for `C`
|
-help: consider further restricting this bound with trait `Bar<5>`
+help: consider further restricting this bound with trait `Bar`
|
LL | pub struct Structure<C: Tec + Bar<5>> {
| ++++++++
diff --git a/tests/ui/associated-types/defaults-suitability.current.stderr b/tests/ui/associated-types/defaults-suitability.current.stderr
index c98ffde25fbac..61247cee1f34d 100644
--- a/tests/ui/associated-types/defaults-suitability.current.stderr
+++ b/tests/ui/associated-types/defaults-suitability.current.stderr
@@ -47,7 +47,7 @@ note: required by a bound in `Foo::Bar`
|
LL | type Bar: Clone = Vec<T>;
| ^^^^^ required by this bound in `Foo::Bar`
-help: consider restricting type parameter `T` with trait `std::clone::Clone`
+help: consider restricting type parameter `T` with trait `Clone`
|
LL | trait Foo<T: std::clone::Clone> {
| +++++++++++++++++++
@@ -132,7 +132,7 @@ LL | Self::Baz: Clone,
...
LL | type Baz = T;
| --- required by a bound in this associated type
-help: consider further restricting type parameter `T` with trait `std::clone::Clone`
+help: consider further restricting type parameter `T` with trait `Clone`
|
LL | Self::Baz: Clone, T: std::clone::Clone
| ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/tests/ui/associated-types/defaults-suitability.next.stderr b/tests/ui/associated-types/defaults-suitability.next.stderr
index c98ffde25fbac..61247cee1f34d 100644
--- a/tests/ui/associated-types/defaults-suitability.next.stderr
+++ b/tests/ui/associated-types/defaults-suitability.next.stderr
@@ -47,7 +47,7 @@ note: required by a bound in `Foo::Bar`
|
LL | type Bar: Clone = Vec<T>;
| ^^^^^ required by this bound in `Foo::Bar`
-help: consider restricting type parameter `T` with trait `std::clone::Clone`
+help: consider restricting type parameter `T` with trait `Clone`
|
LL | trait Foo<T: std::clone::Clone> {
| +++++++++++++++++++
@@ -132,7 +132,7 @@ LL | Self::Baz: Clone,
...
LL | type Baz = T;
| --- required by a bound in this associated type
-help: consider further restricting type parameter `T` with trait `std::clone::Clone`
+help: consider further restricting type parameter `T` with trait `Clone`
|
LL | Self::Baz: Clone, T: std::clone::Clone
| ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr b/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
index 9d7e0bfee91d1..b2a86bb7f75e1 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `for<'b> T: X<'b, T>` is not satisfied
LL | impl<S, T> X<'_, T> for (S,) {
| ^^^^^^^^ the trait `for<'b> X<'b, T>` is not implemented for `T`
|
-help: consider restricting type parameter `T` with trait `for<'b> X<'b, T>`
+help: consider restricting type parameter `T` with trait `X`
|
LL | impl<S, T: for<'b> X<'b, T>> X<'_, T> for (S,) {
| ++++++++++++++++++
diff --git a/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr b/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
index 83afa02397bac..0815bdce16fc3 100644
--- a/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
+++ b/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `copy`
|
LL | fn copy<U: Setup + ?Sized>(from: &U::From) -> U::From {
| ^^^^^ required by this bound in `copy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
| +++++++++++++++++++
diff --git a/tests/ui/associated-types/issue-43784-associated-type.stderr b/tests/ui/associated-types/issue-43784-associated-type.stderr
index 3c91143e90aa8..ba4e683194f10 100644
--- a/tests/ui/associated-types/issue-43784-associated-type.stderr
+++ b/tests/ui/associated-types/issue-43784-associated-type.stderr
@@ -14,7 +14,7 @@ note: required by a bound in `Complete::Assoc`
|
LL | type Assoc: Partial<Self>;
| ^^^^^^^^^^^^^ required by this bound in `Complete::Assoc`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> Complete for T {
| +++++++++++++++++++
diff --git a/tests/ui/async-await/issue-70818.stderr b/tests/ui/async-await/issue-70818.stderr
index 654ab42d24f7c..8de6a825042bb 100644
--- a/tests/ui/async-await/issue-70818.stderr
+++ b/tests/ui/async-await/issue-70818.stderr
@@ -9,7 +9,7 @@ note: captured value is not `Send`
|
LL | async { (ty, ty1) }
| ^^^ has type `U` which is not `Send`
-help: consider restricting type parameter `U` with trait `std::marker::Send`
+help: consider restricting type parameter `U` with trait `Send`
|
LL | fn foo<T: Send, U: std::marker::Send>(ty: T, ty1: U) -> impl Future<Output = (T, U)> + Send {
| +++++++++++++++++++
diff --git a/tests/ui/async-await/issue-86507.stderr b/tests/ui/async-await/issue-86507.stderr
index be0c656339143..781ff8fddd199 100644
--- a/tests/ui/async-await/issue-86507.stderr
+++ b/tests/ui/async-await/issue-86507.stderr
@@ -14,7 +14,7 @@ note: captured value is not `Send` because `&` references cannot be sent unless
LL | let x = x;
| ^ has type `&T` which is not `Send`, because `T` is not `Sync`
= note: required for the cast from `Pin<Box<{async block@$DIR/issue-86507.rs:18:17: 18:27}>>` to `Pin<Box<(dyn Future<Output = ()> + Send + 'async_trait)>>`
-help: consider further restricting this bound with trait `std::marker::Sync`
+help: consider further restricting this bound with trait `Sync`
|
LL | fn bar<'me, 'async_trait, T: Send + std::marker::Sync>(x: &'me T)
| +++++++++++++++++++
diff --git a/tests/ui/binop/issue-93927.stderr b/tests/ui/binop/issue-93927.stderr
index f8b1a2d84bcbe..d244311d72158 100644
--- a/tests/ui/binop/issue-93927.stderr
+++ b/tests/ui/binop/issue-93927.stderr
@@ -6,7 +6,7 @@ LL | val == val
| |
| MyType<T>
|
-help: consider further restricting this bound with trait `std::cmp::Eq`
+help: consider further restricting this bound with trait `Eq`
|
LL | fn cond<T: PartialEq + std::cmp::Eq>(val: MyType<T>) -> bool {
| ++++++++++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
index 968ac25f60035..3fdca557a2bec 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send+Sync { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | impl <T: Sync+'static + std::marker::Send> Foo for (T,) { }
| +++++++++++++++++++
@@ -27,7 +27,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send+Sync { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound with trait `std::marker::Sync`
+help: consider further restricting this bound with trait `Sync`
|
LL | impl <T: Send + std::marker::Sync> Foo for (T,T) { }
| +++++++++++++++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
index 325f11d702701..2c1db3cd3a346 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
@@ -14,7 +14,7 @@ note: required by a bound in `RequiresRequiresShareAndSend`
|
LL | pub trait RequiresRequiresShareAndSend : RequiresShare + Send { }
| ^^^^ required by this bound in `RequiresRequiresShareAndSend`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | impl <T:Sync+'static + std::marker::Send> RequiresRequiresShareAndSend for X<T> { }
| +++++++++++++++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
index 5847233a3120b..c66e0fbc33333 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | impl <T: Sync+'static + std::marker::Send> Foo for T { }
| +++++++++++++++++++
diff --git a/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr b/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
index 13cb074591220..3227b7aea83cc 100644
--- a/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
+++ b/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `X`
|
LL | struct X<F> where F: FnOnce() + 'static + Send {
| ^^^^ required by this bound in `X`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + std::marker::Send {
| +++++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound in `X`
|
LL | struct X<F> where F: FnOnce() + 'static + Send {
| ^^^^ required by this bound in `X`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + std::marker::Send {
| +++++++++++++++++++
diff --git a/tests/ui/closures/closure-bounds-subtype.stderr b/tests/ui/closures/closure-bounds-subtype.stderr
index 73ecd2ef70afa..71a92fe3d0b4b 100644
--- a/tests/ui/closures/closure-bounds-subtype.stderr
+++ b/tests/ui/closures/closure-bounds-subtype.stderr
@@ -15,7 +15,7 @@ help: use parentheses to call this type parameter
|
LL | take_const_owned(f());
| ++
-help: consider further restricting this bound with trait `std::marker::Sync`
+help: consider further restricting this bound with trait `Sync`
|
LL | fn give_owned<F>(f: F) where F: FnOnce() + Send + std::marker::Sync {
| +++++++++++++++++++
diff --git a/tests/ui/const-generics/issues/issue-61336-2.stderr b/tests/ui/const-generics/issues/issue-61336-2.stderr
index e89e936c4cfa1..92a704da8b45e 100644
--- a/tests/ui/const-generics/issues/issue-61336-2.stderr
+++ b/tests/ui/const-generics/issues/issue-61336-2.stderr
@@ -7,7 +7,7 @@ LL | [x; { N }]
= note: the `Copy` trait is required because this value will be copied for each element of the array
= help: consider using `core::array::from_fn` to initialize the array
= help: see https://doc.rust-lang.org/stable/std/array/fn.from_fn.html for more information
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
| +++++++++++++++++++
diff --git a/tests/ui/const-generics/issues/issue-61336.stderr b/tests/ui/const-generics/issues/issue-61336.stderr
index a1ab680c3895a..43e8f5c044a13 100644
--- a/tests/ui/const-generics/issues/issue-61336.stderr
+++ b/tests/ui/const-generics/issues/issue-61336.stderr
@@ -7,7 +7,7 @@ LL | [x; N]
= note: the `Copy` trait is required because this value will be copied for each element of the array
= help: consider using `core::array::from_fn` to initialize the array
= help: see https://doc.rust-lang.org/stable/std/array/fn.from_fn.html for more information
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
| +++++++++++++++++++
diff --git a/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr b/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
index 33e6b2959ff3f..74ec052f6ecb7 100644
--- a/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
+++ b/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
@@ -12,7 +12,7 @@ LL | fn unsatisfied(self)
LL | where
LL | T: Bar<N>,
| ^^^^^^ required by this bound in `Foo::<T, N>::unsatisfied`
-help: consider restricting type parameter `T` with trait `Bar<N>`
+help: consider restricting type parameter `T` with trait `Bar`
|
LL | impl<T: Bar<N>, const N: usize> Foo<T, N> {
| ++++++++
diff --git a/tests/ui/dropck/explicit-drop-bounds.bad1.stderr b/tests/ui/dropck/explicit-drop-bounds.bad1.stderr
index bbfa858a18390..2caa779ffabac 100644
--- a/tests/ui/dropck/explicit-drop-bounds.bad1.stderr
+++ b/tests/ui/dropck/explicit-drop-bounds.bad1.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `DropMe`
|
LL | struct DropMe<T: Copy>(T);
| ^^^^ required by this bound in `DropMe`
-help: consider further restricting type parameter `T` with trait `std::marker::Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | [T; 1]: Copy, T: std::marker::Copy // But `[T; 1]: Copy` does not imply `T: Copy`
| ~~~~~~~~~~~~~~~~~~~~~~
@@ -25,7 +25,7 @@ note: required by a bound in `DropMe`
|
LL | struct DropMe<T: Copy>(T);
| ^^^^ required by this bound in `DropMe`
-help: consider further restricting type parameter `T` with trait `std::marker::Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | [T; 1]: Copy, T: std::marker::Copy // But `[T; 1]: Copy` does not imply `T: Copy`
| ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/tests/ui/dropck/explicit-drop-bounds.bad2.stderr b/tests/ui/dropck/explicit-drop-bounds.bad2.stderr
index 8d8da4d6c33bb..5851731e83461 100644
--- a/tests/ui/dropck/explicit-drop-bounds.bad2.stderr
+++ b/tests/ui/dropck/explicit-drop-bounds.bad2.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `DropMe`
|
LL | struct DropMe<T: Copy>(T);
| ^^^^ required by this bound in `DropMe`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> Drop for DropMe<T>
| +++++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound in `DropMe`
|
LL | struct DropMe<T: Copy>(T);
| ^^^^ required by this bound in `DropMe`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> Drop for DropMe<T>
| +++++++++++++++++++
diff --git a/tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr b/tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr
index 5148cc272fdec..b221195a7bd5c 100644
--- a/tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr
+++ b/tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr
@@ -73,7 +73,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q` with trait `std::iter::Iterator`
+help: consider restricting type parameter `Q` with trait `Iterator`
|
LL | fn example<Q: std::iter::Iterator>(q: Q) {
| +++++++++++++++++++++
@@ -100,7 +100,7 @@ note: required by a bound in `want`
|
LL | fn want<V: T1>(_x: V) {}
| ^^ required by this bound in `want`
-help: consider restricting type parameter `Q` with trait `std::iter::Iterator`
+help: consider restricting type parameter `Q` with trait `Iterator`
|
LL | fn example<Q: std::iter::Iterator>(q: Q) {
| +++++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/generic-associated-types-where.stderr b/tests/ui/generic-associated-types/generic-associated-types-where.stderr
index ccb2dd4078414..7dce34650d78c 100644
--- a/tests/ui/generic-associated-types/generic-associated-types-where.stderr
+++ b/tests/ui/generic-associated-types/generic-associated-types-where.stderr
@@ -5,7 +5,7 @@ LL | type Assoc2<T> = Vec<T>;
| ^^^^^^ `T` cannot be formatted with the default formatter
|
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
-help: consider restricting type parameter `T` with trait `std::fmt::Display`
+help: consider restricting type parameter `T` with trait `Display`
|
LL | type Assoc2<T: std::fmt::Display> = Vec<T>;
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/impl_bounds.stderr b/tests/ui/generic-associated-types/impl_bounds.stderr
index cb78a5b646f4d..aa56505dd300b 100644
--- a/tests/ui/generic-associated-types/impl_bounds.stderr
+++ b/tests/ui/generic-associated-types/impl_bounds.stderr
@@ -41,7 +41,7 @@ LL | trait Foo {
LL | type C where Self: Clone;
| ^ this trait's associated type doesn't have the requirement `Fooy<T>: Copy`
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> Foo for Fooy<T> {
| +++++++++++++++++++
@@ -66,7 +66,7 @@ LL | trait Foo {
LL | fn d() where Self: Clone;
| ^ this trait's method doesn't have the requirement `Fooy<T>: Copy`
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> Foo for Fooy<T> {
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr b/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
index cdb35b9859702..ac91bdcf3e932 100644
--- a/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
+++ b/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `UnsafeCopy::Item`
|
LL | type Item<'a>: Copy;
| ^^^^ required by this bound in `UnsafeCopy::Item`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> UnsafeCopy for T {
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr b/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
index 575bc8bc3e7da..d98071efe8311 100644
--- a/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
+++ b/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Fun::F`
|
LL | type F<'a>: Fn() -> u32;
| ^^^^^^^^^^^ required by this bound in `Fun::F`
-help: consider restricting type parameter `T` with trait `Fn()`
+help: consider restricting type parameter `T` with trait `Fn`
|
LL | impl<T: Fn()> Fun for T {
| ++++++
diff --git a/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr b/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
index 0aaeee510d91d..cd4c06a8660a8 100644
--- a/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
+++ b/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Fun::F`
|
LL | type F<'a>: Fn() -> u32;
| ^^^^^^^^^^^ required by this bound in `Fun::F`
-help: consider restricting type parameter `T` with trait `Fn()`
+help: consider restricting type parameter `T` with trait `Fn`
|
LL | impl<T: Fn()> Fun for T {
| ++++++
diff --git a/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr b/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
index ccc20f8a14a9e..12f9949a0d304 100644
--- a/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
+++ b/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Fun::F`
|
LL | type F<'a>: Fn() -> u32;
| ^^^^^^^^^^^ required by this bound in `Fun::F`
-help: consider restricting type parameter `T` with trait `Fn()`
+help: consider restricting type parameter `T` with trait `Fn`
|
LL | impl<T: Fn()> Fun for T {
| ++++++
diff --git a/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr b/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
index 6eecb8a38770f..8b23f60953061 100644
--- a/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
+++ b/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Fun::F`
|
LL | type F<'a>: Fn() -> u32;
| ^^^^^^^^^^^ required by this bound in `Fun::F`
-help: consider restricting type parameter `T` with trait `Fn()`
+help: consider restricting type parameter `T` with trait `Fn`
|
LL | impl<T: Fn()> Fun for T {
| ++++++
diff --git a/tests/ui/generic-associated-types/issue-74824.current.stderr b/tests/ui/generic-associated-types/issue-74824.current.stderr
index 7e245181444f2..3a72db27097f7 100644
--- a/tests/ui/generic-associated-types/issue-74824.current.stderr
+++ b/tests/ui/generic-associated-types/issue-74824.current.stderr
@@ -23,7 +23,7 @@ note: required by a bound in `UnsafeCopy::Copy`
|
LL | type Copy<T>: Copy = Box<T>;
| ^^^^ required by this bound in `UnsafeCopy::Copy`
-help: consider restricting type parameter `T` with trait `std::clone::Clone`
+help: consider restricting type parameter `T` with trait `Clone`
|
LL | type Copy<T: std::clone::Clone>: Copy = Box<T>;
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-74824.next.stderr b/tests/ui/generic-associated-types/issue-74824.next.stderr
index 7e245181444f2..3a72db27097f7 100644
--- a/tests/ui/generic-associated-types/issue-74824.next.stderr
+++ b/tests/ui/generic-associated-types/issue-74824.next.stderr
@@ -23,7 +23,7 @@ note: required by a bound in `UnsafeCopy::Copy`
|
LL | type Copy<T>: Copy = Box<T>;
| ^^^^ required by this bound in `UnsafeCopy::Copy`
-help: consider restricting type parameter `T` with trait `std::clone::Clone`
+help: consider restricting type parameter `T` with trait `Clone`
|
LL | type Copy<T: std::clone::Clone>: Copy = Box<T>;
| +++++++++++++++++++
diff --git a/tests/ui/generic-associated-types/missing-bounds.stderr b/tests/ui/generic-associated-types/missing-bounds.stderr
index 2e3667f55e3c9..b10dbf6908e32 100644
--- a/tests/ui/generic-associated-types/missing-bounds.stderr
+++ b/tests/ui/generic-associated-types/missing-bounds.stderr
@@ -71,7 +71,7 @@ LL | Self(self.0 + rhs.0)
| |
| B
|
-help: consider restricting type parameter `B` with trait `std::ops::Add<Output = B>`
+help: consider restricting type parameter `B` with trait `Add`
|
LL | impl<B: std::ops::Add<Output = B>> Add for D<B> {
| +++++++++++++++++++++++++++
diff --git a/tests/ui/higher-ranked/structually-relate-aliases.stderr b/tests/ui/higher-ranked/structually-relate-aliases.stderr
index 0eb147d81933b..025fcc5e17021 100644
--- a/tests/ui/higher-ranked/structually-relate-aliases.stderr
+++ b/tests/ui/higher-ranked/structually-relate-aliases.stderr
@@ -5,7 +5,7 @@ error[E0277]: the trait bound `for<'a> T: ToUnit<'a>` is not satisfied
LL | impl<T> Overlap<for<'a> fn(&'a (), Assoc<'a, T>)> for T {}
| ^^^^^^^^^^^^ the trait `for<'a> ToUnit<'a>` is not implemented for `T`
|
-help: consider restricting type parameter `T` with trait `for<'a> ToUnit<'a>`
+help: consider restricting type parameter `T` with trait `ToUnit`
|
LL | impl<T: for<'a> ToUnit<'a>> Overlap<for<'a> fn(&'a (), Assoc<'a, T>)> for T {}
| ++++++++++++++++++++
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
index fd23f3f128914..63b03aeea3d74 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
@@ -13,7 +13,7 @@ LL | fn want_bar_for_any_ccx<B>(b: &B)
| -------------------- required by a bound in this function
LL | where B : for<'ccx> Bar<'ccx>
| ^^^^^^^^^^^^^^^^^^^ required by this bound in `want_bar_for_any_ccx`
-help: consider further restricting this bound with trait `for<'ccx> Bar<'ccx>`
+help: consider further restricting this bound with trait `Bar`
|
LL | where B : Qux + for<'ccx> Bar<'ccx>
| +++++++++++++++++++++
diff --git a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.stderr b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.stderr
index 1eaf3e4ca64e3..5080d35bdde27 100644
--- a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-85455.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `for<'a> T: SomeTrait<'a>` is not satisfied
LL | callee::<fn(&()) -> <T as SomeTrait<'_>>::Associated>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> SomeTrait<'a>` is not implemented for `T`
|
-help: consider restricting type parameter `T` with trait `for<'a> SomeTrait<'a>`
+help: consider restricting type parameter `T` with trait `SomeTrait`
|
LL | fn give_me_ice<T: for<'a> SomeTrait<'a>>() {
| +++++++++++++++++++++++
@@ -15,7 +15,7 @@ error[E0277]: the trait bound `for<'a> T: SomeTrait<'a>` is not satisfied
LL | callee::<fn(&()) -> <T as SomeTrait<'_>>::Associated>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> SomeTrait<'a>` is not implemented for `T`
|
-help: consider restricting type parameter `T` with trait `for<'a> SomeTrait<'a>`
+help: consider restricting type parameter `T` with trait `SomeTrait`
|
LL | fn give_me_ice<T: for<'a> SomeTrait<'a>>() {
| +++++++++++++++++++++++
diff --git a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
index 47c0d1df8a48a..f86601ef1190a 100644
--- a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
+++ b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
@@ -17,7 +17,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| ------- ^^^^^^^^^^^ ^
| |
| unsatisfied trait bound introduced here
-help: consider further restricting this bound with trait `MyFn<i32>`
+help: consider further restricting this bound with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -43,7 +43,7 @@ LL | fn autobatch<F>(self) -> impl Trait
...
LL | F: Callback<Self::CallbackArg>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<Sender as ChannelSender>::autobatch`
-help: consider further restricting this bound with trait `MyFn<i32>`
+help: consider further restricting this bound with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -68,7 +68,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider further restricting this bound with trait `MyFn<i32>`
+help: consider further restricting this bound with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -121,7 +121,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider further restricting this bound with trait `MyFn<i32>`
+help: consider further restricting this bound with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -137,7 +137,7 @@ note: required by a bound in `Callback`
|
LL | trait Callback<A>: MyFn<A, Output = Self::Ret> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Callback`
-help: consider further restricting this bound with trait `MyFn<i32>`
+help: consider further restricting this bound with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
diff --git a/tests/ui/impl-trait/issue-55872-1.stderr b/tests/ui/impl-trait/issue-55872-1.stderr
index caca075a600bc..28bbb45c0960b 100644
--- a/tests/ui/impl-trait/issue-55872-1.stderr
+++ b/tests/ui/impl-trait/issue-55872-1.stderr
@@ -17,7 +17,7 @@ LL | (S::default(), T::default())
| ---------------------------- return type was inferred to be `(S, T)` here
|
= note: required because it appears within the type `(S, T)`
-help: consider further restricting this bound with trait `std::marker::Copy`
+help: consider further restricting this bound with trait `Copy`
|
LL | impl<S: Default + std::marker::Copy> Bar for S {
| +++++++++++++++++++
@@ -32,7 +32,7 @@ LL | (S::default(), T::default())
| ---------------------------- return type was inferred to be `(S, T)` here
|
= note: required because it appears within the type `(S, T)`
-help: consider further restricting this bound with trait `std::marker::Copy`
+help: consider further restricting this bound with trait `Copy`
|
LL | fn foo<T: Default + std::marker::Copy>() -> Self::E {
| +++++++++++++++++++
diff --git a/tests/ui/issues/issue-6738.stderr b/tests/ui/issues/issue-6738.stderr
index 74f0d6341a739..f22d6a2e4686c 100644
--- a/tests/ui/issues/issue-6738.stderr
+++ b/tests/ui/issues/issue-6738.stderr
@@ -6,7 +6,7 @@ LL | self.x += v.x;
| |
| cannot use `+=` on type `T`
|
-help: consider restricting type parameter `T` with trait `std::ops::AddAssign`
+help: consider restricting type parameter `T` with trait `AddAssign`
|
LL | impl<T: std::ops::AddAssign> Foo<T> {
| +++++++++++++++++++++
diff --git a/tests/ui/kindck/kindck-impl-type-params.stderr b/tests/ui/kindck/kindck-impl-type-params.stderr
index 4cc5219c97ca6..a0a4ef09216f6 100644
--- a/tests/ui/kindck/kindck-impl-type-params.stderr
+++ b/tests/ui/kindck/kindck-impl-type-params.stderr
@@ -12,7 +12,7 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&S<T>` to `&dyn Gettable<T>`
-help: consider restricting type parameter `T` with trait `std::marker::Send`
+help: consider restricting type parameter `T` with trait `Send`
|
LL | fn f<T: std::marker::Send>(val: T) {
| +++++++++++++++++++
@@ -31,7 +31,7 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&S<T>` to `&dyn Gettable<T>`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn f<T: std::marker::Copy>(val: T) {
| +++++++++++++++++++
@@ -50,7 +50,7 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&S<T>` to `&dyn Gettable<T>`
-help: consider restricting type parameter `T` with trait `std::marker::Send`
+help: consider restricting type parameter `T` with trait `Send`
|
LL | fn g<T: std::marker::Send>(val: T) {
| +++++++++++++++++++
@@ -69,7 +69,7 @@ LL | impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&S<T>` to `&dyn Gettable<T>`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn g<T: std::marker::Copy>(val: T) {
| +++++++++++++++++++
diff --git a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
index f4007e34a12da..c2bea92e05565 100644
--- a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
+++ b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
@@ -6,7 +6,7 @@ LL | impl<A, B> FnOnce<A> for CachedFun<A, B>
|
note: required by a bound in `FnOnce`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound with unstable trait `std::marker::Tuple`
+help: consider further restricting this bound with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -19,7 +19,7 @@ LL | impl<A, B> FnMut<A> for CachedFun<A, B>
|
note: required by a bound in `FnMut`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound with unstable trait `std::marker::Tuple`
+help: consider further restricting this bound with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
LL | extern "rust-call" fn call_once(mut self, a: A) -> Self::Output {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
|
-help: consider further restricting this bound with unstable trait `std::marker::Tuple`
+help: consider further restricting this bound with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -41,7 +41,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
LL | extern "rust-call" fn call_mut(&mut self, a: A) -> Self::Output {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
|
-help: consider further restricting this bound with unstable trait `std::marker::Tuple`
+help: consider further restricting this bound with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -56,7 +56,7 @@ LL | self.call_mut(a)
|
note: required by a bound in `call_mut`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound with unstable trait `std::marker::Tuple`
+help: consider further restricting this bound with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
diff --git a/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr b/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
index 70497504bb088..d0d4d04e28a38 100644
--- a/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
+++ b/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
@@ -4,7 +4,7 @@ error[E0277]: cannot multiply `T` by `T`
LL | type Alias<T> = <T as std::ops::Mul>::Output;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `T * T`
|
-help: consider restricting type parameter `T` with trait `std::ops::Mul`
+help: consider restricting type parameter `T` with trait `Mul`
|
LL | type Alias<T: std::ops::Mul> = <T as std::ops::Mul>::Output;
| +++++++++++++++
diff --git a/tests/ui/methods/filter-relevant-fn-bounds.stderr b/tests/ui/methods/filter-relevant-fn-bounds.stderr
index da11c332797be..8b5240e3d4fca 100644
--- a/tests/ui/methods/filter-relevant-fn-bounds.stderr
+++ b/tests/ui/methods/filter-relevant-fn-bounds.stderr
@@ -8,7 +8,7 @@ LL | | where
LL | | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| |___________________________________________________^ the trait `for<'a> Output<'a>` is not implemented for `F`
|
-help: consider further restricting this bound with trait `for<'a> Output<'a>`
+help: consider further restricting this bound with trait `Output`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + for<'a> Output<'a>,
| ++++++++++++++++++++
@@ -19,7 +19,7 @@ error[E0277]: the trait bound `for<'a> F: Output<'a>` is not satisfied
LL | fn do_something_wrapper<O, F>(self, _: F)
| ^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> Output<'a>` is not implemented for `F`
|
-help: consider further restricting this bound with trait `for<'a> Output<'a>`
+help: consider further restricting this bound with trait `Output`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + for<'a> Output<'a>,
| ++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0277]: the trait bound `F: Output<'_>` is not satisfied
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Output<'_>` is not implemented for `F`
|
-help: consider further restricting this bound with trait `Output<'_>`
+help: consider further restricting this bound with trait `Output`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + Output<'_>,
| ++++++++++++
@@ -41,7 +41,7 @@ error[E0277]: the trait bound `F: Output<'_>` is not satisfied
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Output<'_>` is not implemented for `F`
|
-help: consider further restricting this bound with trait `Output<'_>`
+help: consider further restricting this bound with trait `Output`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + Output<'_>,
| ++++++++++++
diff --git a/tests/ui/mir/validate/validate-unsize-cast.stderr b/tests/ui/mir/validate/validate-unsize-cast.stderr
index d2ba786d5d594..9aaf2413b34c3 100644
--- a/tests/ui/mir/validate/validate-unsize-cast.stderr
+++ b/tests/ui/mir/validate/validate-unsize-cast.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `CastTo`
|
LL | pub trait CastTo<U: ?Sized>: Unsize<U> {}
| ^^^^^^^^^ required by this bound in `CastTo`
-help: consider further restricting this bound with unstable trait `std::marker::Unsize<U>`
+help: consider further restricting this bound with unstable trait `Unsize`
|
LL | impl<T: ?Sized + std::marker::Unsize<U>, U: ?Sized> CastTo<U> for T {}
| ++++++++++++++++++++++++
diff --git a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr b/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
index d7fdbcce5bc57..80b003bbcc56a 100644
--- a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
+++ b/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
@@ -6,7 +6,7 @@ LL | let _ = s == t;
| |
| &[T]
|
-help: consider restricting type parameter `T` with trait `std::cmp::PartialEq`
+help: consider restricting type parameter `T` with trait `PartialEq`
|
LL | pub fn foo<T: std::cmp::PartialEq>(s: &[T], t: &[T]) {
| +++++++++++++++++++++
diff --git a/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr b/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
index 92fe54e3d892e..ce5bcccde0f19 100644
--- a/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
+++ b/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
@@ -81,7 +81,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider restricting type parameter `T` with traits `Copy + Trait`
+help: consider restricting type parameter `T` with traits `Copy` and `Trait`
|
LL | fn duplicate_custom<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) {
| ++++++++++++++
@@ -97,7 +97,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider restricting type parameter `T` with traits `Copy + Trait`
+help: consider restricting type parameter `T` with traits `Copy` and `Trait`
|
LL | fn duplicate_custom_1<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) where {
| ++++++++++++++
@@ -113,7 +113,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound with traits `Copy + Trait`
+help: consider further restricting this bound with traits `Copy` and `Trait`
|
LL | T: A + Copy + Trait,
| ++++++++++++++
@@ -129,7 +129,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound with traits `Copy + Trait`
+help: consider further restricting this bound with traits `Copy` and `Trait`
|
LL | T: A + Copy + Trait,
| ++++++++++++++
@@ -145,7 +145,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound with traits `Copy + Trait`
+help: consider further restricting this bound with traits `Copy` and `Trait`
|
LL | fn duplicate_custom_4<T: A + Copy + Trait>(t: S<T>) -> (S<T>, S<T>)
| ++++++++++++++
diff --git a/tests/ui/phantom-auto-trait.stderr b/tests/ui/phantom-auto-trait.stderr
index cc2ddde39737c..ffd4c3a0e1ad0 100644
--- a/tests/ui/phantom-auto-trait.stderr
+++ b/tests/ui/phantom-auto-trait.stderr
@@ -23,7 +23,7 @@ note: required by a bound in `is_zen`
|
LL | fn is_zen<T: Zen>(_: T) {}
| ^^^ required by this bound in `is_zen`
-help: consider restricting type parameter `T` with trait `std::marker::Sync`
+help: consider restricting type parameter `T` with trait `Sync`
|
LL | fn not_sync<T: std::marker::Sync>(x: Guard<T>) {
| +++++++++++++++++++
@@ -58,7 +58,7 @@ note: required by a bound in `is_zen`
|
LL | fn is_zen<T: Zen>(_: T) {}
| ^^^ required by this bound in `is_zen`
-help: consider restricting type parameter `T` with trait `std::marker::Sync`
+help: consider restricting type parameter `T` with trait `Sync`
|
LL | fn nested_not_sync<T: std::marker::Sync>(x: Nested<Guard<T>>) {
| +++++++++++++++++++
diff --git a/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr b/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
index 37e0ef0408562..87f0f47f2401e 100644
--- a/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
+++ b/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `for<'z> T: Trait2<'y, 'z>` is not satisfied
LL | fn callee<'x, 'y, T>(t: &'x dyn for<'z> Trait1< <T as Trait2<'y, 'z>>::Foo >)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'z> Trait2<'y, 'z>` is not implemented for `T`
|
-help: consider restricting type parameter `T` with trait `for<'z> Trait2<'y, 'z>`
+help: consider restricting type parameter `T` with trait `Trait2`
|
LL | fn callee<'x, 'y, T: for<'z> Trait2<'y, 'z>>(t: &'x dyn for<'z> Trait1< <T as Trait2<'y, 'z>>::Foo >)
| ++++++++++++++++++++++++
@@ -17,7 +17,7 @@ LL | |
LL | | }
| |_^ the trait `for<'z> Trait2<'y, 'z>` is not implemented for `T`
|
-help: consider restricting type parameter `T` with trait `for<'z> Trait2<'y, 'z>`
+help: consider restricting type parameter `T` with trait `Trait2`
|
LL | fn callee<'x, 'y, T: for<'z> Trait2<'y, 'z>>(t: &'x dyn for<'z> Trait1< <T as Trait2<'y, 'z>>::Foo >)
| ++++++++++++++++++++++++
diff --git a/tests/ui/specialization/default-generic-associated-type-bound.stderr b/tests/ui/specialization/default-generic-associated-type-bound.stderr
index d14026281ed95..3c606ba1e10db 100644
--- a/tests/ui/specialization/default-generic-associated-type-bound.stderr
+++ b/tests/ui/specialization/default-generic-associated-type-bound.stderr
@@ -20,7 +20,7 @@ note: required by a bound in `X::U`
|
LL | type U<'a>: PartialEq<&'a Self> where Self: 'a;
| ^^^^^^^^^^^^^^^^^^^ required by this bound in `X::U`
-help: consider further restricting this bound with trait `std::cmp::PartialEq`
+help: consider further restricting this bound with trait `PartialEq`
|
LL | impl<T: 'static + std::cmp::PartialEq> X for T {
| +++++++++++++++++++++
diff --git a/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr b/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
index b3a53c95cd57c..4a51a7dfa47fa 100644
--- a/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
@@ -19,7 +19,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo<'a, T: Eq + 'a> { }
| ^^ required by this bound in `Foo`
-help: consider restricting type parameter `U` with trait `std::cmp::Eq`
+help: consider restricting type parameter `U` with trait `Eq`
|
LL | default impl<U: std::cmp::Eq> Foo<'static, U> for () {}
| ++++++++++++++
diff --git a/tests/ui/specialization/issue-33017.stderr b/tests/ui/specialization/issue-33017.stderr
index e04af087b5c8d..29a82a4d87519 100644
--- a/tests/ui/specialization/issue-33017.stderr
+++ b/tests/ui/specialization/issue-33017.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `UncheckedCopy::Output`
|
LL | type Output: From<Self> + Copy + Into<Self>;
| ^^^^ required by this bound in `UncheckedCopy::Output`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> UncheckedCopy for T {
| +++++++++++++++++++
diff --git a/tests/ui/specialization/min_specialization/issue-79224.stderr b/tests/ui/specialization/min_specialization/issue-79224.stderr
index ebf7ee08a68a1..7d107c459e5e6 100644
--- a/tests/ui/specialization/min_specialization/issue-79224.stderr
+++ b/tests/ui/specialization/min_specialization/issue-79224.stderr
@@ -5,7 +5,7 @@ LL | impl<B: ?Sized> Display for Cow<'_, B> {
| ^^^^^^^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound with trait `std::clone::Clone`
+help: consider further restricting this bound with trait `Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -17,7 +17,7 @@ LL | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound with trait `std::clone::Clone`
+help: consider further restricting this bound with trait `Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -29,7 +29,7 @@ LL | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
| ^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound with trait `std::clone::Clone`
+help: consider further restricting this bound with trait `Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -47,7 +47,7 @@ LL | | }
| |_____^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound with trait `std::clone::Clone`
+help: consider further restricting this bound with trait `Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/bound-suggestions.stderr b/tests/ui/suggestions/bound-suggestions.stderr
index d4db21ff7b53e..ea6fbfc211dea 100644
--- a/tests/ui/suggestions/bound-suggestions.stderr
+++ b/tests/ui/suggestions/bound-suggestions.stderr
@@ -5,7 +5,7 @@ LL | println!("{:?}", t);
| ^ `impl Sized` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::fmt::Debug`
+help: consider further restricting this bound with trait `Debug`
|
LL | fn test_impl(t: impl Sized + std::fmt::Debug) {
| +++++++++++++++++
@@ -17,7 +17,7 @@ LL | println!("{:?}", t);
| ^ `T` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `std::fmt::Debug`
+help: consider restricting type parameter `T` with trait `Debug`
|
LL | fn test_no_bounds<T: std::fmt::Debug>(t: T) {
| +++++++++++++++++
@@ -29,7 +29,7 @@ LL | println!("{:?}", t);
| ^ `T` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::fmt::Debug`
+help: consider further restricting this bound with trait `Debug`
|
LL | fn test_one_bound<T: Sized + std::fmt::Debug>(t: T) {
| +++++++++++++++++
@@ -41,7 +41,7 @@ LL | println!("{:?} {:?}", x, y);
| ^ `Y` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting type parameter `Y` with trait `std::fmt::Debug`
+help: consider further restricting type parameter `Y` with trait `Debug`
|
LL | fn test_no_bounds_where<X, Y>(x: X, y: Y) where X: std::fmt::Debug, Y: std::fmt::Debug {
| ~~~~~~~~~~~~~~~~~~~~
@@ -53,7 +53,7 @@ LL | println!("{:?}", x);
| ^ `X` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::fmt::Debug`
+help: consider further restricting this bound with trait `Debug`
|
LL | fn test_one_bound_where<X>(x: X) where X: Sized + std::fmt::Debug {
| +++++++++++++++++
@@ -65,7 +65,7 @@ LL | println!("{:?}", x);
| ^ `X` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::fmt::Debug`
+help: consider further restricting this bound with trait `Debug`
|
LL | fn test_many_bounds_where<X>(x: X) where X: Sized + std::fmt::Debug, X: Sized {
| +++++++++++++++++
diff --git a/tests/ui/suggestions/derive-clone-for-eq.stderr b/tests/ui/suggestions/derive-clone-for-eq.stderr
index 6fb331057f445..eae0b0ae81755 100644
--- a/tests/ui/suggestions/derive-clone-for-eq.stderr
+++ b/tests/ui/suggestions/derive-clone-for-eq.stderr
@@ -14,7 +14,7 @@ LL | impl<T: Clone, U> PartialEq<U> for Struct<T>
note: required by a bound in `Eq`
--> $SRC_DIR/core/src/cmp.rs:LL:COL
= note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `std::clone::Clone`
+help: consider restricting type parameter `T` with trait `Clone`
|
LL | pub struct Struct<T: std::clone::Clone>(T);
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/derive-macro-missing-bounds.stderr b/tests/ui/suggestions/derive-macro-missing-bounds.stderr
index 8df2fcd992de5..37a5f4932ff27 100644
--- a/tests/ui/suggestions/derive-macro-missing-bounds.stderr
+++ b/tests/ui/suggestions/derive-macro-missing-bounds.stderr
@@ -38,7 +38,7 @@ LL | impl<T: Debug + Trait> Debug for Inner<T> {
= note: required for `&c::Inner<T>` to implement `Debug`
= note: required for the cast from `&&c::Inner<T>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `c::Trait`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | struct Outer<T: c::Trait>(Inner<T>);
| ++++++++++
@@ -60,7 +60,7 @@ LL | impl<T> Debug for Inner<T> where T: Debug, T: Trait {
= note: required for `&d::Inner<T>` to implement `Debug`
= note: required for the cast from `&&d::Inner<T>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `d::Trait`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | struct Outer<T: d::Trait>(Inner<T>);
| ++++++++++
@@ -82,7 +82,7 @@ LL | impl<T> Debug for Inner<T> where T: Debug + Trait {
= note: required for `&e::Inner<T>` to implement `Debug`
= note: required for the cast from `&&e::Inner<T>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `e::Trait`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | struct Outer<T: e::Trait>(Inner<T>);
| ++++++++++
@@ -104,7 +104,7 @@ LL | impl<T: Debug> Debug for Inner<T> where T: Trait {
= note: required for `&f::Inner<T>` to implement `Debug`
= note: required for the cast from `&&f::Inner<T>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `f::Trait`
+help: consider restricting type parameter `T` with trait `Trait`
|
LL | struct Outer<T: f::Trait>(Inner<T>);
| ++++++++++
diff --git a/tests/ui/suggestions/issue-97677.stderr b/tests/ui/suggestions/issue-97677.stderr
index c1054204e775f..7fe091ef71c7f 100644
--- a/tests/ui/suggestions/issue-97677.stderr
+++ b/tests/ui/suggestions/issue-97677.stderr
@@ -6,7 +6,7 @@ LL | n + 10
| |
| N
|
-help: consider restricting type parameter `N` with trait `std::ops::Add<i32, Output = N>`
+help: consider restricting type parameter `N` with trait `Add`
|
LL | fn add_ten<N: std::ops::Add<i32, Output = N>>(n: N) -> N {
| ++++++++++++++++++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
index 1b2042fa7a4d8..e5af79ba970c3 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
-help: consider further restricting this bound with trait `std::marker::Copy`
+help: consider further restricting this bound with trait `Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -32,7 +32,7 @@ LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: required for the cast from `&Vector2<K>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::marker::Copy`
+help: consider further restricting this bound with trait `Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -52,7 +52,7 @@ note: required by a bound in `Vector2`
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::marker::Copy`
+help: consider further restricting this bound with trait `Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -74,7 +74,7 @@ LL | #[derive(Debug, Copy, Clone)]
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::marker::Copy`
+help: consider further restricting this bound with trait `Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
index bf422221f6e6b..6b07e5f74c109 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
@@ -29,7 +29,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone>{
| ^^^^^ required by this bound in `Vector2`
-help: consider further restricting this bound with trait `std::fmt::Debug`
+help: consider further restricting this bound with trait `Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
@@ -44,7 +44,7 @@ LL | pub loc: Vector2<K>,
| ^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::fmt::Debug`
+help: consider further restricting this bound with trait `Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
@@ -59,7 +59,7 @@ LL | pub size: Vector2<K>
| ^^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `std::fmt::Debug`
+help: consider further restricting this bound with trait `Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
index a1a3e84acf6a4..8b5cced4c4aaa 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
@@ -29,7 +29,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^^ required by this bound in `Vector2`
-help: consider restricting type parameter `K` with trait `std::fmt::Debug`
+help: consider restricting type parameter `K` with trait `Debug`
|
LL | pub struct AABB<K: std::fmt::Debug> {
| +++++++++++++++++
@@ -45,7 +45,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
-help: consider restricting type parameter `K` with trait `std::marker::Copy`
+help: consider restricting type parameter `K` with trait `Copy`
|
LL | pub struct AABB<K: std::marker::Copy> {
| +++++++++++++++++++
@@ -68,7 +68,7 @@ LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: required for the cast from `&Vector2<K>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K` with trait `std::marker::Copy`
+help: consider restricting type parameter `K` with trait `Copy`
|
LL | pub struct AABB<K: std::marker::Copy> {
| +++++++++++++++++++
@@ -83,7 +83,7 @@ LL | pub loc: Vector2<K>,
| ^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K` with trait `std::fmt::Debug`
+help: consider restricting type parameter `K` with trait `Debug`
|
LL | pub struct AABB<K: std::fmt::Debug> {
| +++++++++++++++++
@@ -103,7 +103,7 @@ note: required by a bound in `Vector2`
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K` with trait `std::marker::Copy`
+help: consider restricting type parameter `K` with trait `Copy`
|
LL | pub struct AABB<K: std::marker::Copy> {
| +++++++++++++++++++
@@ -118,7 +118,7 @@ LL | pub size: Vector2<K>,
| ^^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K` with trait `std::fmt::Debug`
+help: consider restricting type parameter `K` with trait `Debug`
|
LL | pub struct AABB<K: std::fmt::Debug> {
| +++++++++++++++++
@@ -140,7 +140,7 @@ LL | #[derive(Debug, Copy, Clone)]
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `K` with trait `std::marker::Copy`
+help: consider restricting type parameter `K` with trait `Copy`
|
LL | pub struct AABB<K: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr b/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
index 327589ba7a88a..600e5ae63d3d4 100644
--- a/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
+++ b/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
@@ -12,7 +12,7 @@ note: the `Copy` impl for `OnlyCopyIfDisplay<S>` requires that `S: std::fmt::Dis
|
LL | struct Wrapper<T>(T);
| ^
-help: consider restricting type parameter `S` with trait `std::fmt::Display`
+help: consider restricting type parameter `S` with trait `Display`
|
LL | impl<S: std::fmt::Display> Copy for Wrapper<OnlyCopyIfDisplay<S>> {}
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/restrict-type-argument.stderr b/tests/ui/suggestions/restrict-type-argument.stderr
index 4ac9c2d310ca6..3bfd18f4f6220 100644
--- a/tests/ui/suggestions/restrict-type-argument.stderr
+++ b/tests/ui/suggestions/restrict-type-argument.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | fn use_impl_sync(val: impl Sync + std::marker::Send) {
| +++++++++++++++++++
@@ -29,7 +29,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | fn use_where<S>(val: S) where S: Sync + std::marker::Send {
| +++++++++++++++++++
@@ -47,7 +47,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | fn use_bound<S: Sync + std::marker::Send>(val: S) {
| +++++++++++++++++++
@@ -65,7 +65,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | Sync + std::marker::Send
| +++++++++++++++++++
@@ -83,7 +83,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | fn use_bound_and_where<S: Sync + std::marker::Send>(val: S) where S: std::fmt::Debug {
| +++++++++++++++++++
@@ -101,7 +101,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider restricting type parameter `S` with trait `std::marker::Send`
+help: consider restricting type parameter `S` with trait `Send`
|
LL | fn use_unbound<S: std::marker::Send>(val: S) {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/trait-impl-bound-suggestions.stderr b/tests/ui/suggestions/trait-impl-bound-suggestions.stderr
index c62b2dd77d363..346d19f1b7727 100644
--- a/tests/ui/suggestions/trait-impl-bound-suggestions.stderr
+++ b/tests/ui/suggestions/trait-impl-bound-suggestions.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ConstrainedStruct`
|
LL | struct ConstrainedStruct<X: Copy> {
| ^^^^ required by this bound in `ConstrainedStruct`
-help: consider further restricting type parameter `X` with trait `std::marker::Copy`
+help: consider further restricting type parameter `X` with trait `Copy`
|
LL | trait InsufficientlyConstrainedGeneric<X=()> where Self: Sized, X: std::marker::Copy {
| ++++++++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound in `ConstrainedStruct`
|
LL | struct ConstrainedStruct<X: Copy> {
| ^^^^ required by this bound in `ConstrainedStruct`
-help: consider further restricting type parameter `X` with trait `std::marker::Copy`
+help: consider further restricting type parameter `X` with trait `Copy`
|
LL | trait InsufficientlyConstrainedGenericWithEmptyWhere<X=()> where Self: Sized, X: std::marker::Copy {
| ++++++++++++++++++++++
@@ -41,7 +41,7 @@ note: required by a bound in `ConstrainedStruct`
|
LL | struct ConstrainedStruct<X: Copy> {
| ^^^^ required by this bound in `ConstrainedStruct`
-help: consider further restricting type parameter `X` with trait `std::marker::Copy`
+help: consider further restricting type parameter `X` with trait `Copy`
|
LL | trait InsufficientlyConstrainedGeneric<X=()> where Self: Sized, X: std::marker::Copy {
| ++++++++++++++++++++++
@@ -57,7 +57,7 @@ note: required by a bound in `ConstrainedStruct`
|
LL | struct ConstrainedStruct<X: Copy> {
| ^^^^ required by this bound in `ConstrainedStruct`
-help: consider further restricting type parameter `X` with trait `std::marker::Copy`
+help: consider further restricting type parameter `X` with trait `Copy`
|
LL | trait InsufficientlyConstrainedGenericWithEmptyWhere<X=()> where Self: Sized, X: std::marker::Copy {
| ++++++++++++++++++++++
diff --git a/tests/ui/trait-bounds/unstable-trait-suggestion.stderr b/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
index fa8e428aa1fec..dfa47f2ab4682 100644
--- a/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
+++ b/tests/ui/trait-bounds/unstable-trait-suggestion.stderr
@@ -24,7 +24,7 @@ LL | for _ in t {}
|
= note: required for `std::ops::Range<T>` to implement `Iterator`
= note: required for `std::ops::Range<T>` to implement `IntoIterator`
-help: consider restricting type parameter `T` with unstable trait `std::iter::Step`
+help: consider restricting type parameter `T` with unstable trait `Step`
|
LL | pub fn baz<T: std::iter::Step>(t: std::ops::Range<T>) {
| +++++++++++++++++
diff --git a/tests/ui/traits/bad-method-typaram-kind.stderr b/tests/ui/traits/bad-method-typaram-kind.stderr
index 630c8b791f7b9..4b8c266793413 100644
--- a/tests/ui/traits/bad-method-typaram-kind.stderr
+++ b/tests/ui/traits/bad-method-typaram-kind.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `Bar::bar`
|
LL | fn bar<T:Send>(&self);
| ^^^^ required by this bound in `Bar::bar`
-help: consider further restricting this bound with trait `std::marker::Send`
+help: consider further restricting this bound with trait `Send`
|
LL | fn foo<T:'static + std::marker::Send>() {
| +++++++++++++++++++
diff --git a/tests/ui/traits/inductive-overflow/two-traits.stderr b/tests/ui/traits/inductive-overflow/two-traits.stderr
index cb21de08b2975..f06ea93ac7c5b 100644
--- a/tests/ui/traits/inductive-overflow/two-traits.stderr
+++ b/tests/ui/traits/inductive-overflow/two-traits.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Magic::X`
|
LL | type X: Trait;
| ^^^^^ required by this bound in `Magic::X`
-help: consider further restricting this bound with trait `std::marker::Sync`
+help: consider further restricting this bound with trait `Sync`
|
LL | impl<T: Magic + std::marker::Sync> Magic for T {
| +++++++++++++++++++
diff --git a/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr b/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
index c305e668bacb2..66c0f53650447 100644
--- a/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
+++ b/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
@@ -18,7 +18,7 @@ LL | c.same_as(22)
| |
| required by a bound introduced by this call
|
-help: consider further restricting this bound with trait `CompareTo<i32>`
+help: consider further restricting this bound with trait `CompareTo`
|
LL | fn with_trait<C:CompareToInts + CompareTo<i32>>(c: &C) -> bool {
| ++++++++++++++++
@@ -41,7 +41,7 @@ LL | CompareTo::same_as(c, 22)
| |
| required by a bound introduced by this call
|
-help: consider further restricting this bound with trait `CompareTo<i32>`
+help: consider further restricting this bound with trait `CompareTo`
|
LL | fn with_ufcs2<C:CompareToInts + CompareTo<i32>>(c: &C) -> bool {
| ++++++++++++++++
diff --git a/tests/ui/traits/issue-43784-supertrait.stderr b/tests/ui/traits/issue-43784-supertrait.stderr
index 1dcbaf7c34791..1a6da70d76daf 100644
--- a/tests/ui/traits/issue-43784-supertrait.stderr
+++ b/tests/ui/traits/issue-43784-supertrait.stderr
@@ -14,7 +14,7 @@ note: required by a bound in `Complete`
|
LL | pub trait Complete: Partial {
| ^^^^^^^ required by this bound in `Complete`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> Complete for T {}
| +++++++++++++++++++
diff --git a/tests/ui/traits/next-solver/dyn-incompatibility.stderr b/tests/ui/traits/next-solver/dyn-incompatibility.stderr
index 5bc5fd8cb5e8d..6398fbddca5e5 100644
--- a/tests/ui/traits/next-solver/dyn-incompatibility.stderr
+++ b/tests/ui/traits/next-solver/dyn-incompatibility.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `copy`
|
LL | fn copy<U: Setup + ?Sized>(from: &U::From) -> U::From {
| ^^^^^ required by this bound in `copy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
| +++++++++++++++++++
@@ -38,7 +38,7 @@ LL | copy::<dyn Setup<From=T>>(t)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `dyn Setup<From = T>`, the trait `Copy` is not implemented for `T`
|
= note: required because it appears within the type `dyn Setup<From = T>`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
| +++++++++++++++++++
diff --git a/tests/ui/traits/next-solver/global-cache-and-parallel-frontend.stderr b/tests/ui/traits/next-solver/global-cache-and-parallel-frontend.stderr
index 87689f2a7ffe4..da269bbeae4c6 100644
--- a/tests/ui/traits/next-solver/global-cache-and-parallel-frontend.stderr
+++ b/tests/ui/traits/next-solver/global-cache-and-parallel-frontend.stderr
@@ -14,7 +14,7 @@ LL | impl<T: Clone, U> PartialEq<U> for Struct<T>
note: required by a bound in `Eq`
--> $SRC_DIR/core/src/cmp.rs:LL:COL
= note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider restricting type parameter `T` with trait `std::clone::Clone`
+help: consider restricting type parameter `T` with trait `Clone`
|
LL | pub struct Struct<T: std::clone::Clone>(T);
| +++++++++++++++++++
diff --git a/tests/ui/tuple/builtin-fail.stderr b/tests/ui/tuple/builtin-fail.stderr
index 6130538d77e59..ccbc5ae2b7513 100644
--- a/tests/ui/tuple/builtin-fail.stderr
+++ b/tests/ui/tuple/builtin-fail.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `assert_is_tuple`
|
LL | fn assert_is_tuple<T: std::marker::Tuple + ?Sized>() {}
| ^^^^^^^^^^^^^^^^^^ required by this bound in `assert_is_tuple`
-help: consider restricting type parameter `T` with unstable trait `std::marker::Tuple`
+help: consider restricting type parameter `T` with unstable trait `Tuple`
|
LL | fn from_param_env<T: std::marker::Tuple>() {
| ++++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr b/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
index 802457426e034..bbb32b2d604d0 100644
--- a/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
+++ b/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
@@ -14,7 +14,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn f<T: Clone>(t: T) -> X<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `T` with trait `std::clone::Clone`
+help: consider restricting type parameter `T` with trait `Clone`
|
LL | pub type X<T: std::clone::Clone> = impl Clone;
| +++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr b/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
index d421e24685e32..8029fc1be8541 100644
--- a/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
+++ b/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Struct`
|
LL | struct Struct<V: Display>(Option<V>);
| ^^^^^^^ required by this bound in `Struct`
-help: consider further restricting this bound with trait `std::fmt::Display`
+help: consider further restricting this bound with trait `Display`
|
LL | type Foo<T: Debug + std::fmt::Display> = (impl Debug, Struct<T>);
| +++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
index b03b58ca0134d..cd6e85764bda4 100644
--- a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
@@ -14,7 +14,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn two<T: Debug, U>(t: T, _: U) -> Two<T, U> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `T` with trait `std::fmt::Debug`
+help: consider restricting type parameter `T` with trait `Debug`
|
LL | type Two<T: std::fmt::Debug, U> = impl Debug;
| +++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
index 97729076ae85c..bf3c4a0e04fe6 100644
--- a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
@@ -14,7 +14,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn three<T, U: Debug>(_: T, u: U) -> Two<T, U> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `U` with trait `std::fmt::Debug`
+help: consider restricting type parameter `U` with trait `Debug`
|
LL | type Two<T, U: std::fmt::Debug> = impl Debug;
| +++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/generic_underconstrained2.stderr b/tests/ui/type-alias-impl-trait/generic_underconstrained2.stderr
index a1561cf41dddc..5506977a3e702 100644
--- a/tests/ui/type-alias-impl-trait/generic_underconstrained2.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_underconstrained2.stderr
@@ -9,7 +9,7 @@ note: required by a bound on the type alias `Underconstrained`
|
LL | type Underconstrained<T: std::fmt::Debug> = impl Send;
| ^^^^^^^^^^^^^^^ required by this bound
-help: consider restricting type parameter `U` with trait `std::fmt::Debug`
+help: consider restricting type parameter `U` with trait `Debug`
|
LL | fn underconstrained<U: std::fmt::Debug>(_: U) -> Underconstrained<U> {
| +++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound on the type alias `Underconstrained2`
|
LL | type Underconstrained2<T: std::fmt::Debug> = impl Send;
| ^^^^^^^^^^^^^^^ required by this bound
-help: consider restricting type parameter `V` with trait `std::fmt::Debug`
+help: consider restricting type parameter `V` with trait `Debug`
|
LL | fn underconstrained2<U, V: std::fmt::Debug>(_: U, _: V) -> Underconstrained2<V> {
| +++++++++++++++++
@@ -46,7 +46,7 @@ note: required by a bound on the type alias `Underconstrained`
|
LL | type Underconstrained<T: std::fmt::Debug> = impl Send;
| ^^^^^^^^^^^^^^^ required by this bound
-help: consider restricting type parameter `U` with trait `std::fmt::Debug`
+help: consider restricting type parameter `U` with trait `Debug`
|
LL | fn underconstrained<U: std::fmt::Debug>(_: U) -> Underconstrained<U> {
| +++++++++++++++++
@@ -67,7 +67,7 @@ note: required by a bound on the type alias `Underconstrained2`
|
LL | type Underconstrained2<T: std::fmt::Debug> = impl Send;
| ^^^^^^^^^^^^^^^ required by this bound
-help: consider restricting type parameter `V` with trait `std::fmt::Debug`
+help: consider restricting type parameter `V` with trait `Debug`
|
LL | fn underconstrained2<U, V: std::fmt::Debug>(_: U, _: V) -> Underconstrained2<V> {
| +++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/issue-52843.stderr b/tests/ui/type-alias-impl-trait/issue-52843.stderr
index 19ca31e2ab01a..6673b03525d06 100644
--- a/tests/ui/type-alias-impl-trait/issue-52843.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-52843.stderr
@@ -14,7 +14,7 @@ note: this definition site has more where clauses than the opaque type
|
LL | fn foo<T: Default>(t: T) -> Foo<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider restricting type parameter `T` with trait `std::default::Default`
+help: consider restricting type parameter `T` with trait `Default`
|
LL | type Foo<T: std::default::Default> = impl Default;
| +++++++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/issue-53092.stderr b/tests/ui/type-alias-impl-trait/issue-53092.stderr
index 3d8bdab57e61f..579902aa3ab28 100644
--- a/tests/ui/type-alias-impl-trait/issue-53092.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-53092.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `make_bug`
|
LL | fn make_bug<T, U: From<T>>() -> Bug<T, U> {
| ^^^^^^^ required by this bound in `make_bug`
-help: consider restricting type parameter `U` with trait `std::convert::From<T>`
+help: consider restricting type parameter `U` with trait `From`
|
LL | pub type Bug<T, U: std::convert::From<T>> = impl Fn(T) -> U + Copy;
| +++++++++++++++++++++++
diff --git a/tests/ui/type/type-check-defaults.stderr b/tests/ui/type/type-check-defaults.stderr
index 87801e5cc9e1e..ab3378eaa4ab6 100644
--- a/tests/ui/type/type-check-defaults.stderr
+++ b/tests/ui/type/type-check-defaults.stderr
@@ -53,7 +53,7 @@ note: required by a bound in `Super`
|
LL | trait Super<T: Copy> { }
| ^^^^ required by this bound in `Super`
-help: consider further restricting type parameter `T` with trait `std::marker::Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | trait Base<T = String>: Super<T> where T: std::marker::Copy { }
| ++++++++++++++++++++++++++
diff --git a/tests/ui/type/type-check/missing_trait_impl.stderr b/tests/ui/type/type-check/missing_trait_impl.stderr
index aa454cce07fd4..033b42e6736d6 100644
--- a/tests/ui/type/type-check/missing_trait_impl.stderr
+++ b/tests/ui/type/type-check/missing_trait_impl.stderr
@@ -6,7 +6,7 @@ LL | let z = x + y;
| |
| T
|
-help: consider restricting type parameter `T` with trait `std::ops::Add`
+help: consider restricting type parameter `T` with trait `Add`
|
LL | fn foo<T: std::ops::Add>(x: T, y: T) {
| +++++++++++++++
@@ -19,7 +19,7 @@ LL | x += x;
| |
| cannot use `+=` on type `T`
|
-help: consider restricting type parameter `T` with trait `std::ops::AddAssign`
+help: consider restricting type parameter `T` with trait `AddAssign`
|
LL | fn bar<T: std::ops::AddAssign>(x: T) {
| +++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0600]: cannot apply unary operator `-` to type `T`
LL | let y = -x;
| ^^ cannot apply unary operator `-`
|
-help: consider restricting type parameter `T` with trait `std::ops::Neg`
+help: consider restricting type parameter `T` with trait `Neg`
|
LL | fn baz<T: std::ops::Neg>(x: T) {
| +++++++++++++++
@@ -41,7 +41,7 @@ error[E0600]: cannot apply unary operator `!` to type `T`
LL | let y = !x;
| ^^ cannot apply unary operator `!`
|
-help: consider restricting type parameter `T` with trait `std::ops::Not`
+help: consider restricting type parameter `T` with trait `Not`
|
LL | fn baz<T: std::ops::Not>(x: T) {
| +++++++++++++++
diff --git a/tests/ui/typeck/bad-index-due-to-nested.stderr b/tests/ui/typeck/bad-index-due-to-nested.stderr
index 4492a21c3ccaf..dd2ce092368a8 100644
--- a/tests/ui/typeck/bad-index-due-to-nested.stderr
+++ b/tests/ui/typeck/bad-index-due-to-nested.stderr
@@ -12,7 +12,7 @@ LL | impl<K, V> Index<&K> for HashMap<K, V>
LL | where
LL | K: Hash,
| ---- unsatisfied trait bound introduced here
-help: consider restricting type parameter `K` with trait `std::hash::Hash`
+help: consider restricting type parameter `K` with trait `Hash`
|
LL | fn index<'a, K: std::hash::Hash, V>(map: &'a HashMap<K, V>, k: K) -> &'a V {
| +++++++++++++++++
@@ -31,7 +31,7 @@ LL | impl<K, V> Index<&K> for HashMap<K, V>
...
LL | V: Copy,
| ---- unsatisfied trait bound introduced here
-help: consider restricting type parameter `V` with trait `std::marker::Copy`
+help: consider restricting type parameter `V` with trait `Copy`
|
LL | fn index<'a, K, V: std::marker::Copy>(map: &'a HashMap<K, V>, k: K) -> &'a V {
| +++++++++++++++++++
diff --git a/tests/ui/typeck/issue-90164.stderr b/tests/ui/typeck/issue-90164.stderr
index 61c2ae3e0ef84..1be9c1a0b6e18 100644
--- a/tests/ui/typeck/issue-90164.stderr
+++ b/tests/ui/typeck/issue-90164.stderr
@@ -13,7 +13,7 @@ note: required by a bound in `copy`
|
LL | fn copy<R: Unpin, W>(_: R, _: W) {}
| ^^^^^ required by this bound in `copy`
-help: consider restricting type parameter `T` with trait `std::marker::Unpin`
+help: consider restricting type parameter `T` with trait `Unpin`
|
LL | fn f<T: std::marker::Unpin>(r: T) {
| ++++++++++++++++++++
diff --git a/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr b/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
index 2e52d0c13d906..d72c56ac71278 100644
--- a/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
+++ b/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T:Send>() {
| ^^^^ required by this bound in `is_send`
-help: consider restricting type parameter `T` with trait `std::marker::Send`
+help: consider restricting type parameter `T` with trait `Send`
|
LL | fn foo<T: std::marker::Send>() {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-enum-bound.stderr b/tests/ui/wf/wf-enum-bound.stderr
index 66b1f294511b3..1f37dc409fc70 100644
--- a/tests/ui/wf/wf-enum-bound.stderr
+++ b/tests/ui/wf/wf-enum-bound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U` with trait `std::marker::Copy`
+help: consider further restricting type parameter `U` with trait `Copy`
|
LL | where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-enum-fields-struct-variant.stderr b/tests/ui/wf/wf-enum-fields-struct-variant.stderr
index ff5874ac3e4bc..f15a31887a203 100644
--- a/tests/ui/wf/wf-enum-fields-struct-variant.stderr
+++ b/tests/ui/wf/wf-enum-fields-struct-variant.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `IsCopy`
|
LL | struct IsCopy<T:Copy> {
| ^^^^ required by this bound in `IsCopy`
-help: consider restricting type parameter `A` with trait `std::marker::Copy`
+help: consider restricting type parameter `A` with trait `Copy`
|
LL | enum AnotherEnum<A: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-enum-fields.stderr b/tests/ui/wf/wf-enum-fields.stderr
index b6bbe6c9bbc54..3b4de77efdc26 100644
--- a/tests/ui/wf/wf-enum-fields.stderr
+++ b/tests/ui/wf/wf-enum-fields.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `IsCopy`
|
LL | struct IsCopy<T:Copy> {
| ^^^^ required by this bound in `IsCopy`
-help: consider restricting type parameter `A` with trait `std::marker::Copy`
+help: consider restricting type parameter `A` with trait `Copy`
|
LL | enum SomeEnum<A: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-fn-where-clause.stderr b/tests/ui/wf/wf-fn-where-clause.stderr
index 940bcbc93fd53..76671dedabf47 100644
--- a/tests/ui/wf/wf-fn-where-clause.stderr
+++ b/tests/ui/wf/wf-fn-where-clause.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U` with trait `std::marker::Copy`
+help: consider further restricting type parameter `U` with trait `Copy`
|
LL | fn foo<T,U>() where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-arg.stderr b/tests/ui/wf/wf-in-fn-arg.stderr
index 2cf51987e45fe..a65f621526b19 100644
--- a/tests/ui/wf/wf-in-fn-arg.stderr
+++ b/tests/ui/wf/wf-in-fn-arg.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn bar<T: std::marker::Copy>(_: &MustBeCopy<T>)
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-ret.stderr b/tests/ui/wf/wf-in-fn-ret.stderr
index 30c29270e2194..3f2b46f8478df 100644
--- a/tests/ui/wf/wf-in-fn-ret.stderr
+++ b/tests/ui/wf/wf-in-fn-ret.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T: Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | fn bar<T: std::marker::Copy>() -> MustBeCopy<T>
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-type-arg.stderr b/tests/ui/wf/wf-in-fn-type-arg.stderr
index 7ceb8ffa365bd..4626b90500a3d 100644
--- a/tests/ui/wf/wf-in-fn-type-arg.stderr
+++ b/tests/ui/wf/wf-in-fn-type-arg.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | struct Bar<T: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-type-ret.stderr b/tests/ui/wf/wf-in-fn-type-ret.stderr
index 2773f9b72822f..2ad405b445165 100644
--- a/tests/ui/wf/wf-in-fn-type-ret.stderr
+++ b/tests/ui/wf/wf-in-fn-type-ret.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | struct Foo<T: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-fn-where-clause.stderr b/tests/ui/wf/wf-in-fn-where-clause.stderr
index 6ad9d7ab92cc8..6a56d1c032f7c 100644
--- a/tests/ui/wf/wf-in-fn-where-clause.stderr
+++ b/tests/ui/wf/wf-in-fn-where-clause.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | trait MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider further restricting type parameter `U` with trait `std::marker::Copy`
+help: consider further restricting type parameter `U` with trait `Copy`
|
LL | where T: MustBeCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-in-obj-type-trait.stderr b/tests/ui/wf/wf-in-obj-type-trait.stderr
index 997c49a7c75a4..5cd5bf5e24eec 100644
--- a/tests/ui/wf/wf-in-obj-type-trait.stderr
+++ b/tests/ui/wf/wf-in-obj-type-trait.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `MustBeCopy`
|
LL | struct MustBeCopy<T:Copy> {
| ^^^^ required by this bound in `MustBeCopy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | struct Bar<T: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr b/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
index db37b05886c02..8b41bb17d2fa7 100644
--- a/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
+++ b/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider restricting type parameter `U` with trait `std::marker::Copy`
+help: consider restricting type parameter `U` with trait `Copy`
|
LL | impl<T,U: std::marker::Copy> Foo<T,U> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-inherent-impl-where-clause.stderr b/tests/ui/wf/wf-inherent-impl-where-clause.stderr
index 4e8886eb60406..216b7a98b13f4 100644
--- a/tests/ui/wf/wf-inherent-impl-where-clause.stderr
+++ b/tests/ui/wf/wf-inherent-impl-where-clause.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U` with trait `std::marker::Copy`
+help: consider further restricting type parameter `U` with trait `Copy`
|
LL | impl<T,U> Foo<T,U> where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-struct-bound.stderr b/tests/ui/wf/wf-struct-bound.stderr
index 87cbe7dd51887..24b4282538dac 100644
--- a/tests/ui/wf/wf-struct-bound.stderr
+++ b/tests/ui/wf/wf-struct-bound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U` with trait `std::marker::Copy`
+help: consider further restricting type parameter `U` with trait `Copy`
|
LL | where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-struct-field.stderr b/tests/ui/wf/wf-struct-field.stderr
index ae63e85972ba3..4449b71bd880e 100644
--- a/tests/ui/wf/wf-struct-field.stderr
+++ b/tests/ui/wf/wf-struct-field.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `IsCopy`
|
LL | struct IsCopy<T:Copy> {
| ^^^^ required by this bound in `IsCopy`
-help: consider restricting type parameter `A` with trait `std::marker::Copy`
+help: consider restricting type parameter `A` with trait `Copy`
|
LL | struct SomeStruct<A: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-trait-associated-type-bound.stderr b/tests/ui/wf/wf-trait-associated-type-bound.stderr
index 25a0d40e8641d..fe6a848f8667f 100644
--- a/tests/ui/wf/wf-trait-associated-type-bound.stderr
+++ b/tests/ui/wf/wf-trait-associated-type-bound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | trait SomeTrait<T: std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/wf/wf-trait-bound.stderr b/tests/ui/wf/wf-trait-bound.stderr
index b8ad005ef7a4b..0a8d9aa7be825 100644
--- a/tests/ui/wf/wf-trait-bound.stderr
+++ b/tests/ui/wf/wf-trait-bound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider further restricting type parameter `U` with trait `std::marker::Copy`
+help: consider further restricting type parameter `U` with trait `Copy`
|
LL | where T: ExtraCopy<U>, U: std::marker::Copy
| ++++++++++++++++++++++
diff --git a/tests/ui/wf/wf-trait-superbound.stderr b/tests/ui/wf/wf-trait-superbound.stderr
index 3d84cd81774c0..9b0205bfe3955 100644
--- a/tests/ui/wf/wf-trait-superbound.stderr
+++ b/tests/ui/wf/wf-trait-superbound.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `ExtraCopy`
|
LL | trait ExtraCopy<T:Copy> { }
| ^^^^ required by this bound in `ExtraCopy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | trait SomeTrait<T: std::marker::Copy>: ExtraCopy<T> {
| +++++++++++++++++++
diff --git a/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr b/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
index b3abbaa0594a7..955ec18f46515 100644
--- a/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
+++ b/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `require_copy`
|
LL | fn require_copy<T: Copy>(x: T) {}
| ^^^^ required by this bound in `require_copy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> Foo<T> {
| +++++++++++++++++++
diff --git a/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr b/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
index 0bfd0537773c4..793851a287175 100644
--- a/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
+++ b/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `require_copy`
|
LL | fn require_copy<T: Copy>(x: T) {}
| ^^^^ required by this bound in `require_copy`
-help: consider restricting type parameter `T` with trait `std::marker::Copy`
+help: consider restricting type parameter `T` with trait `Copy`
|
LL | impl<T: std::marker::Copy> Foo<T> for Bar<T> {
| +++++++++++++++++++
From d860e5b088a0030c55b8850d10ab231d86fc2969 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Thu, 28 Nov 2024 21:57:48 +0000
Subject: [PATCH 05/10] Mention type parameter in more cases and don't suggest
~const bound already there
---
.../src/diagnostics/conflict_errors.rs | 7 +++---
.../rustc_const_eval/src/check_consts/ops.rs | 2 +-
compiler/rustc_middle/src/ty/diagnostics.rs | 25 +++++++------------
tests/ui/associated-types/issue-59324.stderr | 8 +++---
tests/ui/async-await/issue-86507.stderr | 2 +-
.../typeck-auto-trait-no-supertraits-2.stderr | 2 +-
tests/ui/binop/binop-consume-args.stderr | 20 +++++++--------
tests/ui/binop/binop-move-semantics.stderr | 4 +--
tests/ui/binop/issue-93927.stderr | 2 +-
tests/ui/borrowck/clone-on-ref.stderr | 4 +--
...builtin-superkinds-double-superkind.stderr | 4 +--
.../builtin-superkinds-in-metadata.stderr | 2 +-
...builtin-superkinds-typaram-not-send.stderr | 2 +-
...ds-cant-promote-superkind-in-struct.stderr | 4 +--
.../ui/closures/closure-bounds-subtype.stderr | 2 +-
tests/ui/consts/fn_trait_refs.stderr | 12 ---------
.../unstable-const-fn-in-libcore.stderr | 4 ---
...igher-ranker-supertraits-transitive.stderr | 2 +-
...-predicate-entailment-error.current.stderr | 10 ++++----
tests/ui/impl-trait/issue-55872-1.stderr | 4 +--
.../impl-trait/normalize-tait-in-const.stderr | 4 ---
...rust-call-abi-not-a-tuple-ice-81974.stderr | 10 ++++----
.../methods/filter-relevant-fn-bounds.stderr | 8 +++---
.../mir/validate/validate-unsize-cast.stderr | 2 +-
tests/ui/moves/issue-34721.stderr | 2 +-
.../use_of_moved_value_copy_suggestions.fixed | 6 ++---
.../use_of_moved_value_copy_suggestions.rs | 6 ++---
...use_of_moved_value_copy_suggestions.stderr | 6 ++---
...fault-generic-associated-type-bound.stderr | 2 +-
.../min_specialization/issue-79224.stderr | 8 +++---
tests/ui/suggestions/assoc-const-as-fn.stderr | 2 +-
tests/ui/suggestions/bound-suggestions.stderr | 8 +++---
tests/ui/suggestions/clone-bounds-121524.rs | 2 +-
.../ui/suggestions/clone-bounds-121524.stderr | 2 +-
.../issue-106443-sugg-clone-for-bound.stderr | 2 +-
...missing-bound-in-derive-copy-impl-2.stderr | 8 +++---
...missing-bound-in-derive-copy-impl-3.stderr | 8 +++---
.../suggestions/restrict-type-argument.stderr | 10 ++++----
.../ui/traits/bad-method-typaram-kind.stderr | 2 +-
.../call-generic-method-chain.stderr | 4 ---
.../call-generic-method-dup-bound.stderr | 8 ------
.../call-generic-method-fail.stderr | 4 ---
.../call-generic-method-pass.stderr | 4 ---
.../const-closure-trait-method-fail.stderr | 4 ---
.../const-closure-trait-method.stderr | 4 ---
.../traits/const-traits/const-closures.stderr | 12 ---------
.../const-traits/trait-where-clause.stderr | 4 +--
.../inductive-overflow/two-traits.stderr | 2 +-
.../repeated-supertrait-ambig.stderr | 4 +--
.../issue-118950-root-region.stderr | 2 +-
.../bounds-are-checked3.stderr | 2 +-
tests/ui/union/issue-81199.stderr | 2 +-
tests/ui/unop/unop-move-semantics.stderr | 2 +-
53 files changed, 106 insertions(+), 172 deletions(-)
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index c11103af476e3..b42c99e1a6d9d 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1450,6 +1450,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
ty::Param(param_ty) => Ok((
generics.type_param(param_ty, tcx),
predicate.trait_ref.print_trait_sugared().to_string(),
+ Some(predicate.trait_ref.def_id),
)),
_ => Err(()),
}
@@ -1463,9 +1464,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
tcx,
hir_generics,
err,
- predicates
- .iter()
- .map(|(param, constraint)| (param.name.as_str(), &**constraint, None)),
+ predicates.iter().map(|(param, constraint, def_id)| {
+ (param.name.as_str(), &**constraint, *def_id)
+ }),
None,
);
}
diff --git a/compiler/rustc_const_eval/src/check_consts/ops.rs b/compiler/rustc_const_eval/src/check_consts/ops.rs
index 489bb54a6f98a..23f2aa4d0296a 100644
--- a/compiler/rustc_const_eval/src/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/check_consts/ops.rs
@@ -140,7 +140,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
err,
param_ty.name.as_str(),
&constraint,
- None,
+ Some(trait_ref.def_id),
None,
);
}
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index 5baf47436fc93..a7548184760a8 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -162,7 +162,7 @@ pub fn suggest_arbitrary_trait_bound<'tcx>(
true
}
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
enum SuggestChangingConstraintsMessage<'a> {
RestrictBoundFurther,
RestrictType { ty: &'a str },
@@ -319,6 +319,11 @@ pub fn suggest_constraining_type_params<'a>(
suggest_changing_unsized_bound(generics, &mut suggestions, param, def_id);
}
}
+ let bound_message = if constraints.iter().any(|(_, def_id, _)| def_id.is_none()) {
+ SuggestChangingConstraintsMessage::RestrictBoundFurther
+ } else {
+ SuggestChangingConstraintsMessage::RestrictTypeFurther { ty: param_name }
+ };
// in the scenario like impl has stricter requirements than trait,
// we should not suggest restrict bound on the impl, here we double check
@@ -389,23 +394,11 @@ pub fn suggest_constraining_type_params<'a>(
format!(" {constraint}")
};
- use SuggestChangingConstraintsMessage::RestrictBoundFurther;
-
if let Some(open_paren_sp) = open_paren_sp {
- suggestions.push((
- open_paren_sp,
- post.clone(),
- "(".to_string(),
- RestrictBoundFurther,
- ));
- suggestions.push((
- span,
- post.clone(),
- format!("){suggestion}"),
- RestrictBoundFurther,
- ));
+ suggestions.push((open_paren_sp, post.clone(), "(".to_string(), bound_message));
+ suggestions.push((span, post.clone(), format!("){suggestion}"), bound_message));
} else {
- suggestions.push((span, post.clone(), suggestion, RestrictBoundFurther));
+ suggestions.push((span, post.clone(), suggestion, bound_message));
}
};
diff --git a/tests/ui/associated-types/issue-59324.stderr b/tests/ui/associated-types/issue-59324.stderr
index e8693135913ad..ec2890cc8e7f6 100644
--- a/tests/ui/associated-types/issue-59324.stderr
+++ b/tests/ui/associated-types/issue-59324.stderr
@@ -7,7 +7,7 @@ LL | |
LL | | Service<AssocType = <Bug as Foo>::OnlyFoo>
| |______________________________________________^ the trait `Foo` is not implemented for `Bug`
|
-help: consider further restricting this bound with trait `Foo`
+help: consider further restricting type parameter `Bug` with trait `Foo`
|
LL | pub trait ThriftService<Bug: NotFoo + Foo>:
| +++++
@@ -24,7 +24,7 @@ LL | |
LL | | }
| |_^ the trait `Foo` is not implemented for `Bug`
|
-help: consider further restricting this bound with trait `Foo`
+help: consider further restricting type parameter `Bug` with trait `Foo`
|
LL | pub trait ThriftService<Bug: NotFoo + Foo>:
| +++++
@@ -38,7 +38,7 @@ LL | | &self,
LL | | ) -> Self::AssocType;
| |_________________________^ the trait `Foo` is not implemented for `Bug`
|
-help: consider further restricting this bound with trait `Foo`
+help: consider further restricting type parameter `Bug` with trait `Foo`
|
LL | pub trait ThriftService<Bug: NotFoo + Foo>:
| +++++
@@ -61,7 +61,7 @@ error[E0277]: the trait bound `Bug: Foo` is not satisfied
LL | ) -> Self::AssocType;
| ^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `Bug`
|
-help: consider further restricting this bound with trait `Foo`
+help: consider further restricting type parameter `Bug` with trait `Foo`
|
LL | pub trait ThriftService<Bug: NotFoo + Foo>:
| +++++
diff --git a/tests/ui/async-await/issue-86507.stderr b/tests/ui/async-await/issue-86507.stderr
index 781ff8fddd199..6385a8c975e34 100644
--- a/tests/ui/async-await/issue-86507.stderr
+++ b/tests/ui/async-await/issue-86507.stderr
@@ -14,7 +14,7 @@ note: captured value is not `Send` because `&` references cannot be sent unless
LL | let x = x;
| ^ has type `&T` which is not `Send`, because `T` is not `Sync`
= note: required for the cast from `Pin<Box<{async block@$DIR/issue-86507.rs:18:17: 18:27}>>` to `Pin<Box<(dyn Future<Output = ()> + Send + 'async_trait)>>`
-help: consider further restricting this bound with trait `Sync`
+help: consider further restricting type parameter `T` with trait `Sync`
|
LL | fn bar<'me, 'async_trait, T: Send + std::marker::Sync>(x: &'me T)
| +++++++++++++++++++
diff --git a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
index 1c73bd26267a1..27e38ce06a435 100644
--- a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
+++ b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
@@ -30,7 +30,7 @@ LL | fn copy<T: Magic>(x: T) -> (T, T) { (x, x) }
| ^ - you could clone this value
| |
| consider constraining this type parameter with `Clone`
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | fn copy<T: Magic + Copy>(x: T) -> (T, T) { (x, x) }
| ++++++
diff --git a/tests/ui/binop/binop-consume-args.stderr b/tests/ui/binop/binop-consume-args.stderr
index 7b0789547831e..d9d92a44766db 100644
--- a/tests/ui/binop/binop-consume-args.stderr
+++ b/tests/ui/binop/binop-consume-args.stderr
@@ -17,7 +17,7 @@ LL | lhs + rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn add<A: Add<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -64,7 +64,7 @@ LL | lhs - rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn sub<A: Sub<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -111,7 +111,7 @@ LL | lhs * rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn mul<A: Mul<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -158,7 +158,7 @@ LL | lhs / rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn div<A: Div<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -205,7 +205,7 @@ LL | lhs % rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn rem<A: Rem<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -252,7 +252,7 @@ LL | lhs & rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn bitand<A: BitAnd<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -299,7 +299,7 @@ LL | lhs | rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn bitor<A: BitOr<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -346,7 +346,7 @@ LL | lhs ^ rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn bitxor<A: BitXor<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -393,7 +393,7 @@ LL | lhs << rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn shl<A: Shl<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
@@ -440,7 +440,7 @@ LL | lhs >> rhs;
| --- you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `A` with trait `Copy`
|
LL | fn shr<A: Shr<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
| ++++++
diff --git a/tests/ui/binop/binop-move-semantics.stderr b/tests/ui/binop/binop-move-semantics.stderr
index e83cc652fff68..2e661c44abd1a 100644
--- a/tests/ui/binop/binop-move-semantics.stderr
+++ b/tests/ui/binop/binop-move-semantics.stderr
@@ -20,7 +20,7 @@ LL | x
| - you could clone this value
note: calling this operator moves the left-hand side
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | fn double_move<T: Add<Output=()> + Copy>(x: T) {
| ++++++
@@ -40,7 +40,7 @@ help: consider cloning the value if the performance cost is acceptable
|
LL | x.clone()
| ++++++++
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | fn move_then_borrow<T: Add<Output=()> + Clone + Copy>(x: T) {
| ++++++
diff --git a/tests/ui/binop/issue-93927.stderr b/tests/ui/binop/issue-93927.stderr
index d244311d72158..ff5ecf66be631 100644
--- a/tests/ui/binop/issue-93927.stderr
+++ b/tests/ui/binop/issue-93927.stderr
@@ -6,7 +6,7 @@ LL | val == val
| |
| MyType<T>
|
-help: consider further restricting this bound with trait `Eq`
+help: consider further restricting type parameter `T` with trait `Eq`
|
LL | fn cond<T: PartialEq + std::cmp::Eq>(val: MyType<T>) -> bool {
| ++++++++++++++
diff --git a/tests/ui/borrowck/clone-on-ref.stderr b/tests/ui/borrowck/clone-on-ref.stderr
index 361724220a354..911c136086cfc 100644
--- a/tests/ui/borrowck/clone-on-ref.stderr
+++ b/tests/ui/borrowck/clone-on-ref.stderr
@@ -12,7 +12,7 @@ LL |
LL | drop(cloned_items);
| ------------ immutable borrow later used here
|
-help: consider further restricting this bound with trait `Clone`
+help: consider further restricting type parameter `T` with trait `Clone`
|
LL | fn foo<T: Default + Clone>(list: &mut Vec<T>) {
| +++++++
@@ -39,7 +39,7 @@ LL | fn bar<T: std::fmt::Display>(x: T) {
| ^ consider constraining this type parameter with `Clone`
LL | let a = &x;
| - you could clone this value
-help: consider further restricting this bound with trait `Clone`
+help: consider further restricting type parameter `T` with trait `Clone`
|
LL | fn bar<T: std::fmt::Display + Clone>(x: T) {
| +++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
index 3fdca557a2bec..9915b772afaf6 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send+Sync { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `T` with trait `Send`
|
LL | impl <T: Sync+'static + std::marker::Send> Foo for (T,) { }
| +++++++++++++++++++
@@ -27,7 +27,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send+Sync { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound with trait `Sync`
+help: consider further restricting type parameter `T` with trait `Sync`
|
LL | impl <T: Send + std::marker::Sync> Foo for (T,T) { }
| +++++++++++++++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
index 2c1db3cd3a346..39a04186981f3 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
@@ -14,7 +14,7 @@ note: required by a bound in `RequiresRequiresShareAndSend`
|
LL | pub trait RequiresRequiresShareAndSend : RequiresShare + Send { }
| ^^^^ required by this bound in `RequiresRequiresShareAndSend`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `T` with trait `Send`
|
LL | impl <T:Sync+'static + std::marker::Send> RequiresRequiresShareAndSend for X<T> { }
| +++++++++++++++++++
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
index c66e0fbc33333..dd273b875aebd 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Foo`
|
LL | trait Foo : Send { }
| ^^^^ required by this bound in `Foo`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `T` with trait `Send`
|
LL | impl <T: Sync+'static + std::marker::Send> Foo for T { }
| +++++++++++++++++++
diff --git a/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr b/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
index 3227b7aea83cc..9ceee477856d6 100644
--- a/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
+++ b/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `X`
|
LL | struct X<F> where F: FnOnce() + 'static + Send {
| ^^^^ required by this bound in `X`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `F` with trait `Send`
|
LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + std::marker::Send {
| +++++++++++++++++++
@@ -25,7 +25,7 @@ note: required by a bound in `X`
|
LL | struct X<F> where F: FnOnce() + 'static + Send {
| ^^^^ required by this bound in `X`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `F` with trait `Send`
|
LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + std::marker::Send {
| +++++++++++++++++++
diff --git a/tests/ui/closures/closure-bounds-subtype.stderr b/tests/ui/closures/closure-bounds-subtype.stderr
index 71a92fe3d0b4b..34c5e0299a751 100644
--- a/tests/ui/closures/closure-bounds-subtype.stderr
+++ b/tests/ui/closures/closure-bounds-subtype.stderr
@@ -15,7 +15,7 @@ help: use parentheses to call this type parameter
|
LL | take_const_owned(f());
| ++
-help: consider further restricting this bound with trait `Sync`
+help: consider further restricting type parameter `F` with trait `Sync`
|
LL | fn give_owned<F>(f: F) where F: FnOnce() + Send + std::marker::Sync {
| +++++++++++++++++++
diff --git a/tests/ui/consts/fn_trait_refs.stderr b/tests/ui/consts/fn_trait_refs.stderr
index 5ccfb3911fd7b..bb7ff76b1255c 100644
--- a/tests/ui/consts/fn_trait_refs.stderr
+++ b/tests/ui/consts/fn_trait_refs.stderr
@@ -212,10 +212,6 @@ LL | f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const Fn()`
- |
-LL | T: ~const Fn<()> + ~const Destruct + ~const Fn(),
- | +++++++++++++
error[E0015]: cannot call non-const closure in constant functions
--> $DIR/fn_trait_refs.rs:23:5
@@ -224,10 +220,6 @@ LL | f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const FnMut()`
- |
-LL | T: ~const FnMut<()> + ~const Destruct + ~const FnMut(),
- | ++++++++++++++++
error[E0015]: cannot call non-const closure in constant functions
--> $DIR/fn_trait_refs.rs:30:5
@@ -236,10 +228,6 @@ LL | f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const FnOnce()`
- |
-LL | T: ~const FnOnce<()> + ~const FnOnce(),
- | +++++++++++++++++
error: aborting due to 25 previous errors
diff --git a/tests/ui/consts/unstable-const-fn-in-libcore.stderr b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
index 6f7b75caff0db..f40c1871e90b9 100644
--- a/tests/ui/consts/unstable-const-fn-in-libcore.stderr
+++ b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
@@ -19,10 +19,6 @@ LL | Opt::None => f(),
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const FnOnce()`
- |
-LL | const fn unwrap_or_else<F: ~const FnOnce() -> T + ~const FnOnce()>(self, f: F) -> T {
- | +++++++++++++++++
error[E0493]: destructor of `F` cannot be evaluated at compile-time
--> $DIR/unstable-const-fn-in-libcore.rs:19:60
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
index 63b03aeea3d74..da6013a4af33f 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
@@ -13,7 +13,7 @@ LL | fn want_bar_for_any_ccx<B>(b: &B)
| -------------------- required by a bound in this function
LL | where B : for<'ccx> Bar<'ccx>
| ^^^^^^^^^^^^^^^^^^^ required by this bound in `want_bar_for_any_ccx`
-help: consider further restricting this bound with trait `Bar`
+help: consider further restricting type parameter `B` with trait `Bar`
|
LL | where B : Qux + for<'ccx> Bar<'ccx>
| +++++++++++++++++++++
diff --git a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
index f86601ef1190a..1ddbd75142f9c 100644
--- a/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
+++ b/tests/ui/impl-trait/in-trait/false-positive-predicate-entailment-error.current.stderr
@@ -17,7 +17,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| ------- ^^^^^^^^^^^ ^
| |
| unsatisfied trait bound introduced here
-help: consider further restricting this bound with trait `MyFn`
+help: consider further restricting type parameter `F` with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -43,7 +43,7 @@ LL | fn autobatch<F>(self) -> impl Trait
...
LL | F: Callback<Self::CallbackArg>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<Sender as ChannelSender>::autobatch`
-help: consider further restricting this bound with trait `MyFn`
+help: consider further restricting type parameter `F` with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -68,7 +68,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider further restricting this bound with trait `MyFn`
+help: consider further restricting type parameter `F` with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -121,7 +121,7 @@ LL | impl<A, F: MyFn<A>> Callback<A> for F {
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider further restricting this bound with trait `MyFn`
+help: consider further restricting type parameter `F` with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
@@ -137,7 +137,7 @@ note: required by a bound in `Callback`
|
LL | trait Callback<A>: MyFn<A, Output = Self::Ret> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Callback`
-help: consider further restricting this bound with trait `MyFn`
+help: consider further restricting type parameter `F` with trait `MyFn`
|
LL | F: Callback<Self::CallbackArg> + MyFn<i32>,
| +++++++++++
diff --git a/tests/ui/impl-trait/issue-55872-1.stderr b/tests/ui/impl-trait/issue-55872-1.stderr
index 28bbb45c0960b..81759760bf13e 100644
--- a/tests/ui/impl-trait/issue-55872-1.stderr
+++ b/tests/ui/impl-trait/issue-55872-1.stderr
@@ -17,7 +17,7 @@ LL | (S::default(), T::default())
| ---------------------------- return type was inferred to be `(S, T)` here
|
= note: required because it appears within the type `(S, T)`
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `S` with trait `Copy`
|
LL | impl<S: Default + std::marker::Copy> Bar for S {
| +++++++++++++++++++
@@ -32,7 +32,7 @@ LL | (S::default(), T::default())
| ---------------------------- return type was inferred to be `(S, T)` here
|
= note: required because it appears within the type `(S, T)`
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | fn foo<T: Default + std::marker::Copy>() -> Self::E {
| +++++++++++++++++++
diff --git a/tests/ui/impl-trait/normalize-tait-in-const.stderr b/tests/ui/impl-trait/normalize-tait-in-const.stderr
index 9054b621bced6..1dd84f10ad862 100644
--- a/tests/ui/impl-trait/normalize-tait-in-const.stderr
+++ b/tests/ui/impl-trait/normalize-tait-in-const.stderr
@@ -33,10 +33,6 @@ LL | fun(filter_positive());
| ^^^^^^^^^^^^^^^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const Fn(&foo::Alias<'_>)`
- |
-LL | const fn with_positive<F: for<'a> ~const Fn(&'a Alias<'a>) + ~const Destruct + ~const Fn(&foo::Alias<'_>)>(fun: F) {
- | ++++++++++++++++++++++++++++
error: aborting due to 4 previous errors
diff --git a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
index c2bea92e05565..3b051ef9a8823 100644
--- a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
+++ b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
@@ -6,7 +6,7 @@ LL | impl<A, B> FnOnce<A> for CachedFun<A, B>
|
note: required by a bound in `FnOnce`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound with unstable trait `Tuple`
+help: consider further restricting type parameter `A` with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -19,7 +19,7 @@ LL | impl<A, B> FnMut<A> for CachedFun<A, B>
|
note: required by a bound in `FnMut`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound with unstable trait `Tuple`
+help: consider further restricting type parameter `A` with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
LL | extern "rust-call" fn call_once(mut self, a: A) -> Self::Output {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
|
-help: consider further restricting this bound with unstable trait `Tuple`
+help: consider further restricting type parameter `A` with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -41,7 +41,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
LL | extern "rust-call" fn call_mut(&mut self, a: A) -> Self::Output {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
|
-help: consider further restricting this bound with unstable trait `Tuple`
+help: consider further restricting type parameter `A` with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
@@ -56,7 +56,7 @@ LL | self.call_mut(a)
|
note: required by a bound in `call_mut`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
-help: consider further restricting this bound with unstable trait `Tuple`
+help: consider further restricting type parameter `A` with unstable trait `Tuple`
|
LL | A: Eq + Hash + Clone + std::marker::Tuple,
| ++++++++++++++++++++
diff --git a/tests/ui/methods/filter-relevant-fn-bounds.stderr b/tests/ui/methods/filter-relevant-fn-bounds.stderr
index 8b5240e3d4fca..0e00adf6ea64f 100644
--- a/tests/ui/methods/filter-relevant-fn-bounds.stderr
+++ b/tests/ui/methods/filter-relevant-fn-bounds.stderr
@@ -8,7 +8,7 @@ LL | | where
LL | | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| |___________________________________________________^ the trait `for<'a> Output<'a>` is not implemented for `F`
|
-help: consider further restricting this bound with trait `Output`
+help: consider further restricting type parameter `F` with trait `Output`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + for<'a> Output<'a>,
| ++++++++++++++++++++
@@ -19,7 +19,7 @@ error[E0277]: the trait bound `for<'a> F: Output<'a>` is not satisfied
LL | fn do_something_wrapper<O, F>(self, _: F)
| ^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> Output<'a>` is not implemented for `F`
|
-help: consider further restricting this bound with trait `Output`
+help: consider further restricting type parameter `F` with trait `Output`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + for<'a> Output<'a>,
| ++++++++++++++++++++
@@ -30,7 +30,7 @@ error[E0277]: the trait bound `F: Output<'_>` is not satisfied
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Output<'_>` is not implemented for `F`
|
-help: consider further restricting this bound with trait `Output`
+help: consider further restricting type parameter `F` with trait `Output`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + Output<'_>,
| ++++++++++++
@@ -41,7 +41,7 @@ error[E0277]: the trait bound `F: Output<'_>` is not satisfied
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Output<'_>` is not implemented for `F`
|
-help: consider further restricting this bound with trait `Output`
+help: consider further restricting type parameter `F` with trait `Output`
|
LL | F: for<'a> FnOnce(<F as Output<'a>>::Type) + Output<'_>,
| ++++++++++++
diff --git a/tests/ui/mir/validate/validate-unsize-cast.stderr b/tests/ui/mir/validate/validate-unsize-cast.stderr
index 9aaf2413b34c3..8449c6a24bd31 100644
--- a/tests/ui/mir/validate/validate-unsize-cast.stderr
+++ b/tests/ui/mir/validate/validate-unsize-cast.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `CastTo`
|
LL | pub trait CastTo<U: ?Sized>: Unsize<U> {}
| ^^^^^^^^^ required by this bound in `CastTo`
-help: consider further restricting this bound with unstable trait `Unsize`
+help: consider further restricting type parameter `T` with unstable trait `Unsize`
|
LL | impl<T: ?Sized + std::marker::Unsize<U>, U: ?Sized> CastTo<U> for T {}
| ++++++++++++++++++++++++
diff --git a/tests/ui/moves/issue-34721.stderr b/tests/ui/moves/issue-34721.stderr
index 30b94072e5e8c..9834d009d2227 100644
--- a/tests/ui/moves/issue-34721.stderr
+++ b/tests/ui/moves/issue-34721.stderr
@@ -18,7 +18,7 @@ note: `Foo::zero` takes ownership of the receiver `self`, which moves `x`
|
LL | fn zero(self) -> Self;
| ^^^^
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | pub fn baz<T: Foo + Copy>(x: T) -> T {
| ++++++
diff --git a/tests/ui/moves/use_of_moved_value_copy_suggestions.fixed b/tests/ui/moves/use_of_moved_value_copy_suggestions.fixed
index bfb855c7fb1f4..a5e0dd819b461 100644
--- a/tests/ui/moves/use_of_moved_value_copy_suggestions.fixed
+++ b/tests/ui/moves/use_of_moved_value_copy_suggestions.fixed
@@ -48,7 +48,7 @@ fn duplicate_custom_1<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) where {
fn duplicate_custom_2<T>(t: S<T>) -> (S<T>, S<T>)
where
T: A + Copy + Trait,
- //~^ HELP consider further restricting this bound
+ //~^ HELP consider further restricting
{
(t, t) //~ use of moved value: `t`
}
@@ -56,14 +56,14 @@ where
fn duplicate_custom_3<T>(t: S<T>) -> (S<T>, S<T>)
where
T: A + Copy + Trait,
- //~^ HELP consider further restricting this bound
+ //~^ HELP consider further restricting
T: B,
{
(t, t) //~ use of moved value: `t`
}
fn duplicate_custom_4<T: A + Copy + Trait>(t: S<T>) -> (S<T>, S<T>)
-//~^ HELP consider further restricting this bound
+//~^ HELP consider further restricting
where
T: B,
{
diff --git a/tests/ui/moves/use_of_moved_value_copy_suggestions.rs b/tests/ui/moves/use_of_moved_value_copy_suggestions.rs
index fbe5a1d74c372..60ca03ed6984a 100644
--- a/tests/ui/moves/use_of_moved_value_copy_suggestions.rs
+++ b/tests/ui/moves/use_of_moved_value_copy_suggestions.rs
@@ -48,7 +48,7 @@ fn duplicate_custom_1<T>(t: S<T>) -> (S<T>, S<T>) where {
fn duplicate_custom_2<T>(t: S<T>) -> (S<T>, S<T>)
where
T: A,
- //~^ HELP consider further restricting this bound
+ //~^ HELP consider further restricting
{
(t, t) //~ use of moved value: `t`
}
@@ -56,14 +56,14 @@ where
fn duplicate_custom_3<T>(t: S<T>) -> (S<T>, S<T>)
where
T: A,
- //~^ HELP consider further restricting this bound
+ //~^ HELP consider further restricting
T: B,
{
(t, t) //~ use of moved value: `t`
}
fn duplicate_custom_4<T: A>(t: S<T>) -> (S<T>, S<T>)
-//~^ HELP consider further restricting this bound
+//~^ HELP consider further restricting
where
T: B,
{
diff --git a/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr b/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
index ce5bcccde0f19..784945dbbaeae 100644
--- a/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
+++ b/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
@@ -113,7 +113,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound with traits `Copy` and `Trait`
+help: consider further restricting type parameter `T` with traits `Copy` and `Trait`
|
LL | T: A + Copy + Trait,
| ++++++++++++++
@@ -129,7 +129,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound with traits `Copy` and `Trait`
+help: consider further restricting type parameter `T` with traits `Copy` and `Trait`
|
LL | T: A + Copy + Trait,
| ++++++++++++++
@@ -145,7 +145,7 @@ LL | (t, t)
| |
| value moved here
|
-help: consider further restricting this bound with traits `Copy` and `Trait`
+help: consider further restricting type parameter `T` with traits `Copy` and `Trait`
|
LL | fn duplicate_custom_4<T: A + Copy + Trait>(t: S<T>) -> (S<T>, S<T>)
| ++++++++++++++
diff --git a/tests/ui/specialization/default-generic-associated-type-bound.stderr b/tests/ui/specialization/default-generic-associated-type-bound.stderr
index 3c606ba1e10db..57d67ac526ac6 100644
--- a/tests/ui/specialization/default-generic-associated-type-bound.stderr
+++ b/tests/ui/specialization/default-generic-associated-type-bound.stderr
@@ -20,7 +20,7 @@ note: required by a bound in `X::U`
|
LL | type U<'a>: PartialEq<&'a Self> where Self: 'a;
| ^^^^^^^^^^^^^^^^^^^ required by this bound in `X::U`
-help: consider further restricting this bound with trait `PartialEq`
+help: consider further restricting type parameter `T` with trait `PartialEq`
|
LL | impl<T: 'static + std::cmp::PartialEq> X for T {
| +++++++++++++++++++++
diff --git a/tests/ui/specialization/min_specialization/issue-79224.stderr b/tests/ui/specialization/min_specialization/issue-79224.stderr
index 7d107c459e5e6..84e526f459785 100644
--- a/tests/ui/specialization/min_specialization/issue-79224.stderr
+++ b/tests/ui/specialization/min_specialization/issue-79224.stderr
@@ -5,7 +5,7 @@ LL | impl<B: ?Sized> Display for Cow<'_, B> {
| ^^^^^^^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound with trait `Clone`
+help: consider further restricting type parameter `B` with trait `Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -17,7 +17,7 @@ LL | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound with trait `Clone`
+help: consider further restricting type parameter `B` with trait `Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -29,7 +29,7 @@ LL | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
| ^^^^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound with trait `Clone`
+help: consider further restricting type parameter `B` with trait `Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
@@ -47,7 +47,7 @@ LL | | }
| |_____^ the trait `Clone` is not implemented for `B`
|
= note: required for `B` to implement `ToOwned`
-help: consider further restricting this bound with trait `Clone`
+help: consider further restricting type parameter `B` with trait `Clone`
|
LL | impl<B: ?Sized + std::clone::Clone> Display for Cow<'_, B> {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/assoc-const-as-fn.stderr b/tests/ui/suggestions/assoc-const-as-fn.stderr
index b660bacd50ba8..6732033e774fe 100644
--- a/tests/ui/suggestions/assoc-const-as-fn.stderr
+++ b/tests/ui/suggestions/assoc-const-as-fn.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `T: GlUniformScalar` is not satisfied
LL | <T as GlUniformScalar>::FACTORY(1, value);
| ^ the trait `GlUniformScalar` is not implemented for `T`
|
-help: consider further restricting this bound with trait `GlUniformScalar`
+help: consider further restricting type parameter `T` with trait `GlUniformScalar`
|
LL | pub fn foo<T: UniformScalar + GlUniformScalar>(value: T) {
| +++++++++++++++++
diff --git a/tests/ui/suggestions/bound-suggestions.stderr b/tests/ui/suggestions/bound-suggestions.stderr
index ea6fbfc211dea..be0ff66092e00 100644
--- a/tests/ui/suggestions/bound-suggestions.stderr
+++ b/tests/ui/suggestions/bound-suggestions.stderr
@@ -5,7 +5,7 @@ LL | println!("{:?}", t);
| ^ `impl Sized` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Debug`
+help: consider further restricting type parameter `impl Sized` with trait `Debug`
|
LL | fn test_impl(t: impl Sized + std::fmt::Debug) {
| +++++++++++++++++
@@ -29,7 +29,7 @@ LL | println!("{:?}", t);
| ^ `T` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Debug`
+help: consider further restricting type parameter `T` with trait `Debug`
|
LL | fn test_one_bound<T: Sized + std::fmt::Debug>(t: T) {
| +++++++++++++++++
@@ -53,7 +53,7 @@ LL | println!("{:?}", x);
| ^ `X` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Debug`
+help: consider further restricting type parameter `X` with trait `Debug`
|
LL | fn test_one_bound_where<X>(x: X) where X: Sized + std::fmt::Debug {
| +++++++++++++++++
@@ -65,7 +65,7 @@ LL | println!("{:?}", x);
| ^ `X` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Debug`
+help: consider further restricting type parameter `X` with trait `Debug`
|
LL | fn test_many_bounds_where<X>(x: X) where X: Sized + std::fmt::Debug, X: Sized {
| +++++++++++++++++
diff --git a/tests/ui/suggestions/clone-bounds-121524.rs b/tests/ui/suggestions/clone-bounds-121524.rs
index 8cd60b452de09..7bc3bfe011769 100644
--- a/tests/ui/suggestions/clone-bounds-121524.rs
+++ b/tests/ui/suggestions/clone-bounds-121524.rs
@@ -6,7 +6,7 @@ trait DoesAThing {}
impl DoesAThing for ThingThatDoesAThing {}
fn clones_impl_ref_inline(thing: &impl DoesAThing) {
- //~^ HELP consider further restricting this bound
+ //~^ HELP consider further restricting type parameter `impl DoesAThing` with trait `Clone`
drops_impl_owned(thing.clone()); //~ ERROR E0277
//~^ NOTE copies the reference
//~| NOTE the trait `DoesAThing` is not implemented for `&impl DoesAThing`
diff --git a/tests/ui/suggestions/clone-bounds-121524.stderr b/tests/ui/suggestions/clone-bounds-121524.stderr
index a389dee5e9e32..92897d87188c3 100644
--- a/tests/ui/suggestions/clone-bounds-121524.stderr
+++ b/tests/ui/suggestions/clone-bounds-121524.stderr
@@ -9,7 +9,7 @@ note: this `clone()` copies the reference, which does not do anything, because `
|
LL | drops_impl_owned(thing.clone());
| ^^^^^
-help: consider further restricting this bound with trait `Clone`
+help: consider further restricting type parameter `impl DoesAThing` with trait `Clone`
|
LL | fn clones_impl_ref_inline(thing: &impl DoesAThing + Clone) {
| +++++++
diff --git a/tests/ui/suggestions/issue-106443-sugg-clone-for-bound.stderr b/tests/ui/suggestions/issue-106443-sugg-clone-for-bound.stderr
index 474de6388e3dd..8b1c0b9a77ad2 100644
--- a/tests/ui/suggestions/issue-106443-sugg-clone-for-bound.stderr
+++ b/tests/ui/suggestions/issue-106443-sugg-clone-for-bound.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `&T: X` is not satisfied
LL | foo(s);
| ^ the trait `X` is not implemented for `&T`
|
-help: consider further restricting this bound with trait `Clone`
+help: consider further restricting type parameter `T` with trait `Clone`
|
LL | fn bar<T: X + Clone>(s: &T) {
| +++++++
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
index e5af79ba970c3..4408fe0a0a4bb 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `K` with trait `Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -32,7 +32,7 @@ LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: required for the cast from `&Vector2<K>` to `&dyn Debug`
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `K` with trait `Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -52,7 +52,7 @@ note: required by a bound in `Vector2`
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ^^^^ required by this bound in `Vector2`
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `K` with trait `Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
@@ -74,7 +74,7 @@ LL | #[derive(Debug, Copy, Clone)]
LL | pub struct Vector2<T: Debug + Copy + Clone> {
| ---- unsatisfied trait bound introduced in this `derive` macro
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `K` with trait `Copy`
|
LL | pub struct AABB<K: Debug + std::marker::Copy> {
| +++++++++++++++++++
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
index 6b07e5f74c109..1bbf6f66ab23f 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
@@ -13,7 +13,7 @@ note: the `Copy` impl for `Vector2<K>` requires that `K: Debug`
LL | pub loc: Vector2<K>,
| ^^^^^^^^^^
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Debug`
+help: consider further restricting type parameter `K` with trait `Debug`
|
LL | pub struct AABB<K: Copy + Debug>{
| +++++++
@@ -29,7 +29,7 @@ note: required by a bound in `Vector2`
|
LL | pub struct Vector2<T: Debug + Copy + Clone>{
| ^^^^^ required by this bound in `Vector2`
-help: consider further restricting this bound with trait `Debug`
+help: consider further restricting type parameter `K` with trait `Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
@@ -44,7 +44,7 @@ LL | pub loc: Vector2<K>,
| ^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Debug`
+help: consider further restricting type parameter `K` with trait `Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
@@ -59,7 +59,7 @@ LL | pub size: Vector2<K>
| ^^^^^^^^^^^^^^^^^^^^ `K` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting this bound with trait `Debug`
+help: consider further restricting type parameter `K` with trait `Debug`
|
LL | pub struct AABB<K: Copy + std::fmt::Debug>{
| +++++++++++++++++
diff --git a/tests/ui/suggestions/restrict-type-argument.stderr b/tests/ui/suggestions/restrict-type-argument.stderr
index 3bfd18f4f6220..dc647fefc282e 100644
--- a/tests/ui/suggestions/restrict-type-argument.stderr
+++ b/tests/ui/suggestions/restrict-type-argument.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `impl Sync` with trait `Send`
|
LL | fn use_impl_sync(val: impl Sync + std::marker::Send) {
| +++++++++++++++++++
@@ -29,7 +29,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `S` with trait `Send`
|
LL | fn use_where<S>(val: S) where S: Sync + std::marker::Send {
| +++++++++++++++++++
@@ -47,7 +47,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `S` with trait `Send`
|
LL | fn use_bound<S: Sync + std::marker::Send>(val: S) {
| +++++++++++++++++++
@@ -65,7 +65,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `S` with trait `Send`
|
LL | Sync + std::marker::Send
| +++++++++++++++++++
@@ -83,7 +83,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `S` with trait `Send`
|
LL | fn use_bound_and_where<S: Sync + std::marker::Send>(val: S) where S: std::fmt::Debug {
| +++++++++++++++++++
diff --git a/tests/ui/traits/bad-method-typaram-kind.stderr b/tests/ui/traits/bad-method-typaram-kind.stderr
index 4b8c266793413..3b3d6e5f832b6 100644
--- a/tests/ui/traits/bad-method-typaram-kind.stderr
+++ b/tests/ui/traits/bad-method-typaram-kind.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `Bar::bar`
|
LL | fn bar<T:Send>(&self);
| ^^^^ required by this bound in `Bar::bar`
-help: consider further restricting this bound with trait `Send`
+help: consider further restricting type parameter `T` with trait `Send`
|
LL | fn foo<T:'static + std::marker::Send>() {
| +++++++++++++++++++
diff --git a/tests/ui/traits/const-traits/call-generic-method-chain.stderr b/tests/ui/traits/const-traits/call-generic-method-chain.stderr
index 401a85bcc5776..21fb19daad4aa 100644
--- a/tests/ui/traits/const-traits/call-generic-method-chain.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-chain.stderr
@@ -42,10 +42,6 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
- |
-LL | const fn equals_self<T: ~const PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
- | ++++++++++++++++++++++++++++
error[E0015]: cannot call non-const fn `<S as PartialEq>::eq` in constant functions
--> $DIR/call-generic-method-chain.rs:16:15
diff --git a/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr b/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
index 2598af92f1201..845949a38bf5a 100644
--- a/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-dup-bound.stderr
@@ -42,10 +42,6 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
- |
-LL | const fn equals_self<T: PartialEq + ~const PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
- | ++++++++++++++++++++++++++++
error[E0015]: cannot call non-const fn `<S as PartialEq>::eq` in constant functions
--> $DIR/call-generic-method-dup-bound.rs:14:15
@@ -62,10 +58,6 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
- |
-LL | const fn equals_self2<T: A + ~const PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
- | ++++++++++++++++++++++++++++
error: aborting due to 8 previous errors
diff --git a/tests/ui/traits/const-traits/call-generic-method-fail.stderr b/tests/ui/traits/const-traits/call-generic-method-fail.stderr
index 2a6c0e0ed1d42..6bacb986fef0c 100644
--- a/tests/ui/traits/const-traits/call-generic-method-fail.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-fail.stderr
@@ -5,10 +5,6 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
- |
-LL | pub const fn equals_self<T: PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
- | ++++++++++++++++++++++++++++
error: aborting due to 1 previous error
diff --git a/tests/ui/traits/const-traits/call-generic-method-pass.stderr b/tests/ui/traits/const-traits/call-generic-method-pass.stderr
index c46cf8f9ab595..0c0037e36b86d 100644
--- a/tests/ui/traits/const-traits/call-generic-method-pass.stderr
+++ b/tests/ui/traits/const-traits/call-generic-method-pass.stderr
@@ -28,10 +28,6 @@ LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const std::cmp::PartialEq`
- |
-LL | const fn equals_self<T: ~const PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
- | ++++++++++++++++++++++++++++
error[E0015]: cannot call non-const fn `<S as PartialEq>::eq` in constant functions
--> $DIR/call-generic-method-pass.rs:16:15
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
index d7b2423f45b5f..a76dc3e82af71 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
+++ b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
@@ -19,10 +19,6 @@ LL | x(())
| ^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const FnOnce(())`
- |
-LL | const fn need_const_closure<T: ~const FnOnce(()) -> i32 + ~const FnOnce(())>(x: T) -> i32 {
- | +++++++++++++++++++
error: aborting due to 3 previous errors
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method.stderr b/tests/ui/traits/const-traits/const-closure-trait-method.stderr
index 23de7f521b1f5..d37ff3d727cea 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method.stderr
+++ b/tests/ui/traits/const-traits/const-closure-trait-method.stderr
@@ -19,10 +19,6 @@ LL | x(())
| ^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const FnOnce(())`
- |
-LL | const fn need_const_closure<T: ~const FnOnce(()) -> i32 + ~const FnOnce(())>(x: T) -> i32 {
- | +++++++++++++++++++
error: aborting due to 3 previous errors
diff --git a/tests/ui/traits/const-traits/const-closures.stderr b/tests/ui/traits/const-traits/const-closures.stderr
index 4a633a5ca2b62..8ceaae16d8e70 100644
--- a/tests/ui/traits/const-traits/const-closures.stderr
+++ b/tests/ui/traits/const-traits/const-closures.stderr
@@ -61,10 +61,6 @@ LL | f() + f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const Fn()`
- |
-LL | const fn answer<F: ~const Fn() -> u8 + ~const Fn()>(f: &F) -> u8 {
- | +++++++++++++
error[E0015]: cannot call non-const closure in constant functions
--> $DIR/const-closures.rs:24:11
@@ -73,10 +69,6 @@ LL | f() + f()
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const Fn()`
- |
-LL | const fn answer<F: ~const Fn() -> u8 + ~const Fn()>(f: &F) -> u8 {
- | +++++++++++++
error[E0015]: cannot call non-const closure in constant functions
--> $DIR/const-closures.rs:12:5
@@ -85,10 +77,6 @@ LL | f() * 7
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-help: consider further restricting this bound with trait `~const Fn()`
- |
-LL | F: ~const FnOnce() -> u8 + ~const Fn(),
- | +++++++++++++
error: aborting due to 11 previous errors
diff --git a/tests/ui/traits/const-traits/trait-where-clause.stderr b/tests/ui/traits/const-traits/trait-where-clause.stderr
index 8a621633b6302..3a15cc63f3223 100644
--- a/tests/ui/traits/const-traits/trait-where-clause.stderr
+++ b/tests/ui/traits/const-traits/trait-where-clause.stderr
@@ -33,7 +33,7 @@ note: required by a bound in `Foo::b`
|
LL | fn b() where Self: ~const Bar;
| ^^^^^^^^^^ required by this bound in `Foo::b`
-help: consider further restricting this bound with trait `Bar`
+help: consider further restricting type parameter `T` with trait `Bar`
|
LL | fn test1<T: Foo + Bar>() {
| +++++
@@ -49,7 +49,7 @@ note: required by a bound in `Foo::c`
|
LL | fn c<T: ~const Bar>();
| ^^^^^^^^^^ required by this bound in `Foo::c`
-help: consider further restricting this bound with trait `Bar`
+help: consider further restricting type parameter `T` with trait `Bar`
|
LL | fn test1<T: Foo + Bar>() {
| +++++
diff --git a/tests/ui/traits/inductive-overflow/two-traits.stderr b/tests/ui/traits/inductive-overflow/two-traits.stderr
index f06ea93ac7c5b..1816e029f1844 100644
--- a/tests/ui/traits/inductive-overflow/two-traits.stderr
+++ b/tests/ui/traits/inductive-overflow/two-traits.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `Magic::X`
|
LL | type X: Trait;
| ^^^^^ required by this bound in `Magic::X`
-help: consider further restricting this bound with trait `Sync`
+help: consider further restricting type parameter `T` with trait `Sync`
|
LL | impl<T: Magic + std::marker::Sync> Magic for T {
| +++++++++++++++++++
diff --git a/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr b/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
index 66c0f53650447..fdf0b1722beaf 100644
--- a/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
+++ b/tests/ui/traits/inheritance/repeated-supertrait-ambig.stderr
@@ -18,7 +18,7 @@ LL | c.same_as(22)
| |
| required by a bound introduced by this call
|
-help: consider further restricting this bound with trait `CompareTo`
+help: consider further restricting type parameter `C` with trait `CompareTo`
|
LL | fn with_trait<C:CompareToInts + CompareTo<i32>>(c: &C) -> bool {
| ++++++++++++++++
@@ -41,7 +41,7 @@ LL | CompareTo::same_as(c, 22)
| |
| required by a bound introduced by this call
|
-help: consider further restricting this bound with trait `CompareTo`
+help: consider further restricting type parameter `C` with trait `CompareTo`
|
LL | fn with_ufcs2<C:CompareToInts + CompareTo<i32>>(c: &C) -> bool {
| ++++++++++++++++
diff --git a/tests/ui/traits/next-solver/issue-118950-root-region.stderr b/tests/ui/traits/next-solver/issue-118950-root-region.stderr
index 523c92aa3b59b..d2a58e95629a4 100644
--- a/tests/ui/traits/next-solver/issue-118950-root-region.stderr
+++ b/tests/ui/traits/next-solver/issue-118950-root-region.stderr
@@ -32,7 +32,7 @@ error[E0277]: the trait bound `T: Overlap<for<'a> fn(Assoc<'a, T>)>` is not sati
LL | impl<T> Overlap<for<'a> fn(Assoc<'a, T>)> for T where Missing: Overlap<T> {}
| ^ the trait `Overlap<for<'a> fn(Assoc<'a, T>)>` is not implemented for `T`
|
-help: consider further restricting type parameter `T` with trait `Overlap<for<'a> fn(Assoc<'a, T>)>`
+help: consider further restricting type parameter `T` with trait `Overlap`
|
LL | impl<T> Overlap<for<'a> fn(Assoc<'a, T>)> for T where Missing: Overlap<T>, T: Overlap<for<'a> fn(Assoc<'a, T>)> {}
| ++++++++++++++++++++++++++++++++++++++
diff --git a/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr b/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
index 8029fc1be8541..c0f6d6780976a 100644
--- a/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
+++ b/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `Struct`
|
LL | struct Struct<V: Display>(Option<V>);
| ^^^^^^^ required by this bound in `Struct`
-help: consider further restricting this bound with trait `Display`
+help: consider further restricting type parameter `T` with trait `Display`
|
LL | type Foo<T: Debug + std::fmt::Display> = (impl Debug, Struct<T>);
| +++++++++++++++++++
diff --git a/tests/ui/union/issue-81199.stderr b/tests/ui/union/issue-81199.stderr
index d815e67d18621..8b78ddcf4a527 100644
--- a/tests/ui/union/issue-81199.stderr
+++ b/tests/ui/union/issue-81199.stderr
@@ -9,7 +9,7 @@ note: required by a bound in `PtrComponents`
|
LL | struct PtrComponents<T: Pointee + ?Sized> {
| ^^^^^^^ required by this bound in `PtrComponents`
-help: consider further restricting this bound with trait `Pointee`
+help: consider further restricting type parameter `T` with trait `Pointee`
|
LL | union PtrRepr<T: ?Sized + Pointee> {
| +++++++++
diff --git a/tests/ui/unop/unop-move-semantics.stderr b/tests/ui/unop/unop-move-semantics.stderr
index 89483b7b9cde3..5b81feaa578af 100644
--- a/tests/ui/unop/unop-move-semantics.stderr
+++ b/tests/ui/unop/unop-move-semantics.stderr
@@ -15,7 +15,7 @@ help: consider cloning the value if the performance cost is acceptable
|
LL | !x.clone();
| ++++++++
-help: consider further restricting this bound with trait `Copy`
+help: consider further restricting type parameter `T` with trait `Copy`
|
LL | fn move_then_borrow<T: Not<Output=T> + Clone + Copy>(x: T) {
| ++++++
From cb4db0a6c6ef642c13f7f08d449acde0336a2c8c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Thu, 28 Nov 2024 22:20:44 +0000
Subject: [PATCH 06/10] Account for `impl Trait` in "add bound" suggestion
message
---
compiler/rustc_middle/src/ty/diagnostics.rs | 6 ++++++
tests/ui/suggestions/bound-suggestions.stderr | 2 +-
tests/ui/suggestions/clone-bounds-121524.rs | 2 +-
tests/ui/suggestions/clone-bounds-121524.stderr | 2 +-
tests/ui/suggestions/restrict-type-argument.stderr | 2 +-
5 files changed, 10 insertions(+), 4 deletions(-)
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index a7548184760a8..49ed69d4e48f5 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -531,6 +531,12 @@ pub fn suggest_constraining_type_params<'a>(
SuggestChangingConstraintsMessage::RestrictBoundFurther => {
format!("consider further restricting this bound with {post}")
}
+ SuggestChangingConstraintsMessage::RestrictTypeFurther { ty }
+ | SuggestChangingConstraintsMessage::RestrictType { ty }
+ if ty.starts_with("impl ") =>
+ {
+ format!("consider restricting opaque type `{ty}` with {post}")
+ }
SuggestChangingConstraintsMessage::RestrictType { ty } => {
format!("consider restricting type parameter `{ty}` with {post}")
}
diff --git a/tests/ui/suggestions/bound-suggestions.stderr b/tests/ui/suggestions/bound-suggestions.stderr
index be0ff66092e00..e30deb11398e6 100644
--- a/tests/ui/suggestions/bound-suggestions.stderr
+++ b/tests/ui/suggestions/bound-suggestions.stderr
@@ -5,7 +5,7 @@ LL | println!("{:?}", t);
| ^ `impl Sized` cannot be formatted using `{:?}` because it doesn't implement `Debug`
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider further restricting type parameter `impl Sized` with trait `Debug`
+help: consider restricting opaque type `impl Sized` with trait `Debug`
|
LL | fn test_impl(t: impl Sized + std::fmt::Debug) {
| +++++++++++++++++
diff --git a/tests/ui/suggestions/clone-bounds-121524.rs b/tests/ui/suggestions/clone-bounds-121524.rs
index 7bc3bfe011769..b7760584ebbc2 100644
--- a/tests/ui/suggestions/clone-bounds-121524.rs
+++ b/tests/ui/suggestions/clone-bounds-121524.rs
@@ -6,7 +6,7 @@ trait DoesAThing {}
impl DoesAThing for ThingThatDoesAThing {}
fn clones_impl_ref_inline(thing: &impl DoesAThing) {
- //~^ HELP consider further restricting type parameter `impl DoesAThing` with trait `Clone`
+ //~^ HELP consider restricting opaque type `impl DoesAThing` with trait `Clone`
drops_impl_owned(thing.clone()); //~ ERROR E0277
//~^ NOTE copies the reference
//~| NOTE the trait `DoesAThing` is not implemented for `&impl DoesAThing`
diff --git a/tests/ui/suggestions/clone-bounds-121524.stderr b/tests/ui/suggestions/clone-bounds-121524.stderr
index 92897d87188c3..bdba8d7e47226 100644
--- a/tests/ui/suggestions/clone-bounds-121524.stderr
+++ b/tests/ui/suggestions/clone-bounds-121524.stderr
@@ -9,7 +9,7 @@ note: this `clone()` copies the reference, which does not do anything, because `
|
LL | drops_impl_owned(thing.clone());
| ^^^^^
-help: consider further restricting type parameter `impl DoesAThing` with trait `Clone`
+help: consider restricting opaque type `impl DoesAThing` with trait `Clone`
|
LL | fn clones_impl_ref_inline(thing: &impl DoesAThing + Clone) {
| +++++++
diff --git a/tests/ui/suggestions/restrict-type-argument.stderr b/tests/ui/suggestions/restrict-type-argument.stderr
index dc647fefc282e..4b6da8a9cd923 100644
--- a/tests/ui/suggestions/restrict-type-argument.stderr
+++ b/tests/ui/suggestions/restrict-type-argument.stderr
@@ -11,7 +11,7 @@ note: required by a bound in `is_send`
|
LL | fn is_send<T: Send>(val: T) {}
| ^^^^ required by this bound in `is_send`
-help: consider further restricting type parameter `impl Sync` with trait `Send`
+help: consider restricting opaque type `impl Sync` with trait `Send`
|
LL | fn use_impl_sync(val: impl Sync + std::marker::Send) {
| +++++++++++++++++++
From af09423967adcd8c89144a46994ed9f5abb2928b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Thu, 28 Nov 2024 22:34:21 +0000
Subject: [PATCH 07/10] fix rustdoc test
---
.../projections-in-super-trait-bound-unsatisfied.stderr | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr b/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
index 75050e65b7e68..045516d7d2ff6 100644
--- a/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
+++ b/tests/rustdoc-ui/synthetic-auto-trait-impls/projections-in-super-trait-bound-unsatisfied.stderr
@@ -4,7 +4,7 @@ error[E0277]: the trait bound `C: Bar<5>` is not satisfied
LL | pub struct Structure<C: Tec> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bar<5>` is not implemented for `C`
|
-help: consider further restricting this bound with trait `Bar`
+help: consider further restricting type parameter `C` with trait `Bar`
|
LL | pub struct Structure<C: Tec + Bar<5>> {
| ++++++++
@@ -15,7 +15,7 @@ error[E0277]: the trait bound `C: Bar<5>` is not satisfied
LL | _field: C::BarType,
| ^^^^^^^^^^ the trait `Bar<5>` is not implemented for `C`
|
-help: consider further restricting this bound with trait `Bar`
+help: consider further restricting type parameter `C` with trait `Bar`
|
LL | pub struct Structure<C: Tec + Bar<5>> {
| ++++++++
From b4664058900fb9c327e5a5c9d676df2e4d6b5a95 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Thu, 28 Nov 2024 23:40:17 +0000
Subject: [PATCH 08/10] Do not talk about "trait `<Foo = Bar>`"
Pass in an appropriate `Option<DefId>` in more cases from hir ty lowering.
---
compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs | 8 +++++++-
compiler/rustc_middle/src/ty/diagnostics.rs | 6 ++++--
.../hr-associated-type-projection-1.stderr | 2 +-
.../issue-68656-unsized-values.stderr | 2 +-
tests/ui/generic-associated-types/missing-bounds.stderr | 6 +++---
tests/ui/suggestions/restrict-existing-type-bounds.stderr | 4 ++--
.../restrict-assoc-type-of-generic-bound.stderr | 2 +-
.../traits/copy-is-not-modulo-regions.not_static.stderr | 2 +-
.../unresolved-assoc-ty-suggest-trait.lazy.stderr | 2 +-
9 files changed, 21 insertions(+), 13 deletions(-)
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index ff449a858d674..2e227ead14a93 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -279,7 +279,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
} else {
let mut err = self.dcx().create_err(err);
if suggest_constraining_type_param(
- tcx, generics, &mut err, &qself_str, &trait_ref, None, None,
+ tcx,
+ generics,
+ &mut err,
+ &qself_str,
+ &trait_ref,
+ Some(best_trait),
+ None,
) && !identically_named
{
// We suggested constraining a type parameter, but the associated item on it
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index 49ed69d4e48f5..a88aea3fa8ee6 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -345,6 +345,7 @@ pub fn suggest_constraining_type_params<'a>(
let mut constraint = constraints.iter().map(|&(c, _, _)| c).collect::<Vec<_>>();
constraint.sort();
constraint.dedup();
+ let all_known = constraints.iter().all(|&(_, def_id, _)| def_id.is_some());
let all_stable = constraints.iter().all(|&(_, _, stable)| stable.is_empty());
let all_unstable = constraints.iter().all(|&(_, _, stable)| !stable.is_empty());
let post = if all_stable || all_unstable {
@@ -360,7 +361,8 @@ pub fn suggest_constraining_type_params<'a>(
trait_names.dedup();
let n = trait_names.len();
let stable = if all_stable { "" } else { "unstable " };
- format!("{stable}trait{} {}", pluralize!(n), match &trait_names[..] {
+ let trait_ = if all_known { "trait" } else { "" };
+ format!("{stable}{trait_}{} {}", pluralize!(n), match &trait_names[..] {
[t] => t.to_string(),
[ts @ .., last] => format!("{} and {last}", ts.join(", ")),
[] => return false,
@@ -370,7 +372,7 @@ pub fn suggest_constraining_type_params<'a>(
let mut trait_names = constraints
.iter()
.map(|&(c, def_id, stable)| match def_id {
- None => format!("{stable}trait `{c}`"),
+ None => format!("`{c}`"),
Some(def_id) => format!("{stable}trait `{}`", tcx.item_name(def_id)),
})
.collect::<Vec<_>>();
diff --git a/tests/ui/associated-types/hr-associated-type-projection-1.stderr b/tests/ui/associated-types/hr-associated-type-projection-1.stderr
index 65ee3236afdec..c322d11925af2 100644
--- a/tests/ui/associated-types/hr-associated-type-projection-1.stderr
+++ b/tests/ui/associated-types/hr-associated-type-projection-1.stderr
@@ -16,7 +16,7 @@ LL | trait UnsafeCopy<'a, T: Copy>
LL | where
LL | for<'b> <Self as UnsafeCopy<'b, T>>::Item: std::ops::Deref<Target = T>,
| ^^^^^^^^^^ required by this bound in `UnsafeCopy`
-help: consider further restricting this bound with trait `<Target = T>`
+help: consider further restricting this bound with `<Target = T>`
|
LL | impl<T: Copy + std::ops::Deref<Target = T>> UnsafeCopy<'_, T> for T {
| ++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr b/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
index c2d5a8ed48dd4..16bfe2ec93373 100644
--- a/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
+++ b/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
@@ -13,7 +13,7 @@ note: required by a bound in `UnsafeCopy::Item`
|
LL | type Item<'a>: std::ops::Deref<Target = T>;
| ^^^^^^^^^^ required by this bound in `UnsafeCopy::Item`
-help: consider further restricting this bound with trait `<Target = T>`
+help: consider further restricting this bound with `<Target = T>`
|
LL | impl<T: Copy + std::ops::Deref<Target = T>> UnsafeCopy<T> for T {
| ++++++++++++
diff --git a/tests/ui/generic-associated-types/missing-bounds.stderr b/tests/ui/generic-associated-types/missing-bounds.stderr
index b10dbf6908e32..c18cc3106f351 100644
--- a/tests/ui/generic-associated-types/missing-bounds.stderr
+++ b/tests/ui/generic-associated-types/missing-bounds.stderr
@@ -35,7 +35,7 @@ note: tuple struct defined here
|
LL | struct A<B>(B);
| ^
-help: consider further restricting this bound with trait `<Output = B>`
+help: consider further restricting this bound with `<Output = B>`
|
LL | impl<B> Add for A<B> where B: Add<Output = B> {
| ++++++++++++
@@ -58,7 +58,7 @@ note: tuple struct defined here
|
LL | struct C<B>(B);
| ^
-help: consider further restricting this bound with trait `<Output = B>`
+help: consider further restricting this bound with `<Output = B>`
|
LL | impl<B: Add<Output = B>> Add for C<B> {
| ++++++++++++
@@ -94,7 +94,7 @@ note: tuple struct defined here
|
LL | struct E<B>(B);
| ^
-help: consider further restricting this bound with trait `<Output = B>`
+help: consider further restricting this bound with `<Output = B>`
|
LL | impl<B: Add<Output = B>> Add for E<B> where <B as Add>::Output = B {
| ++++++++++++
diff --git a/tests/ui/suggestions/restrict-existing-type-bounds.stderr b/tests/ui/suggestions/restrict-existing-type-bounds.stderr
index 8fff4ca5d95fb..45dab9bec5daa 100644
--- a/tests/ui/suggestions/restrict-existing-type-bounds.stderr
+++ b/tests/ui/suggestions/restrict-existing-type-bounds.stderr
@@ -20,7 +20,7 @@ LL | Ok(self)
| this argument influences the type of `Ok`
note: tuple variant defined here
--> $SRC_DIR/core/src/result.rs:LL:COL
-help: consider further restricting this bound with trait `<Output = T>`
+help: consider further restricting this bound with `<Output = T>`
|
LL | impl<T: TryAdd<Output = T>> TryAdd for Option<T> {
| ++++++++++++
@@ -47,7 +47,7 @@ LL | Ok(self)
| this argument influences the type of `Ok`
note: tuple variant defined here
--> $SRC_DIR/core/src/result.rs:LL:COL
-help: consider further restricting this bound with trait `, Output = T`
+help: consider further restricting this bound with `, Output = T`
|
LL | impl<T: TryAdd<Error = X, Output = T>> TryAdd for Other<T> {
| ++++++++++++
diff --git a/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr b/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
index c1dda283d9d13..ddadee3ea43fb 100644
--- a/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
+++ b/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
@@ -11,7 +11,7 @@ LL | return a.bar();
= note: expected type parameter `B`
found associated type `<A as MyTrait>::T`
= note: the caller chooses a type for `B` which can be different from `<A as MyTrait>::T`
-help: consider further restricting this bound with trait `<T = B>`
+help: consider further restricting this bound with `<T = B>`
|
LL | pub fn foo<A: MyTrait<T = B>, B>(a: A) -> B {
| +++++++
diff --git a/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr b/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
index 760a9c603ded1..02170a127dbd3 100644
--- a/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
+++ b/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
@@ -12,7 +12,7 @@ note: the `Copy` impl for `Foo<'any>` requires that `'any: 'static`
|
LL | struct Bar<'lt>(Foo<'lt>);
| ^^^^^^^^
-help: consider restricting type parameter `'any` with trait `'static`
+help: consider restricting type parameter `'any` with `'static`
|
LL | impl<'any: 'static> Copy for Bar<'any> {}
| +++++++++
diff --git a/tests/ui/type-alias/unresolved-assoc-ty-suggest-trait.lazy.stderr b/tests/ui/type-alias/unresolved-assoc-ty-suggest-trait.lazy.stderr
index a3935efcd7f2e..885c6ec9d8e8e 100644
--- a/tests/ui/type-alias/unresolved-assoc-ty-suggest-trait.lazy.stderr
+++ b/tests/ui/type-alias/unresolved-assoc-ty-suggest-trait.lazy.stderr
@@ -30,7 +30,7 @@ error[E0220]: associated type `Proj` not found for `T`
LL | type ProjOf<T> = T::Proj;
| ^^^^ there is an associated type `Proj` in the trait `Parametrized`
|
-help: consider restricting type parameter `T` with trait `Parametrized</* 'a, T, N */>`
+help: consider restricting type parameter `T` with trait `Parametrized`
|
LL | type ProjOf<T: Parametrized</* 'a, T, N */>> = T::Proj;
| ++++++++++++++++++++++++++++++
From 6277fb0a3f56b0ecec5679b3b3520ba3d4614743 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Fri, 29 Nov 2024 17:32:13 +0000
Subject: [PATCH 09/10] Use run-make `diff` output for stable output test
---
.../missing-bound.stderr | 12 ++++++++++++
tests/run-make/missing-unstable-trait-bound/rmake.rs | 8 +++++---
2 files changed, 17 insertions(+), 3 deletions(-)
create mode 100644 tests/run-make/missing-unstable-trait-bound/missing-bound.stderr
diff --git a/tests/run-make/missing-unstable-trait-bound/missing-bound.stderr b/tests/run-make/missing-unstable-trait-bound/missing-bound.stderr
new file mode 100644
index 0000000000000..7196a1a6fed77
--- /dev/null
+++ b/tests/run-make/missing-unstable-trait-bound/missing-bound.stderr
@@ -0,0 +1,12 @@
+error[E0277]: the trait bound `T: Step` is not satisfied
+ --> missing-bound.rs:2:14
+ |
+2 | for _ in t {}
+ | ^ the trait `Step` is not implemented for `T`
+ |
+ = note: required for `std::ops::Range<T>` to implement `Iterator`
+ = note: required for `std::ops::Range<T>` to implement `IntoIterator`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/run-make/missing-unstable-trait-bound/rmake.rs b/tests/run-make/missing-unstable-trait-bound/rmake.rs
index 1e0cb1336a4a8..20f77f7c9aa0d 100644
--- a/tests/run-make/missing-unstable-trait-bound/rmake.rs
+++ b/tests/run-make/missing-unstable-trait-bound/rmake.rs
@@ -6,10 +6,10 @@
// Ensure that on stable we don't suggest restricting with an unsafe trait and we continue
// mentioning the rest of the obligation chain.
-use run_make_support::{rust_lib_name, rustc};
+use run_make_support::{diff, rust_lib_name, rustc};
fn main() {
- rustc()
+ let out = rustc()
.env("RUSTC_BOOTSTRAP", "-1")
.input("missing-bound.rs")
.run_fail()
@@ -18,5 +18,7 @@ fn main() {
r#"
= note: required for `std::ops::Range<T>` to implement `Iterator`
= note: required for `std::ops::Range<T>` to implement `IntoIterator`"#,
- );
+ )
+ .stderr_utf8();
+ diff().expected_file("missing-bound.stderr").actual_text("(stable rustc)", &out).run()
}
From 25ad0478cb0975f10db6db3abb28d54df8e07430 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 7 Dec 2024 22:18:51 +0000
Subject: [PATCH 10/10] Tweak wording
---
compiler/rustc_middle/src/ty/diagnostics.rs | 10 +++++-----
.../hr-associated-type-projection-1.stderr | 2 +-
.../issue-68656-unsized-values.stderr | 2 +-
.../ui/generic-associated-types/missing-bounds.stderr | 6 +++---
.../suggestions/restrict-existing-type-bounds.stderr | 4 ++--
.../restrict-assoc-type-of-generic-bound.stderr | 2 +-
6 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index a88aea3fa8ee6..604f1da26c648 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -361,10 +361,10 @@ pub fn suggest_constraining_type_params<'a>(
trait_names.dedup();
let n = trait_names.len();
let stable = if all_stable { "" } else { "unstable " };
- let trait_ = if all_known { "trait" } else { "" };
- format!("{stable}{trait_}{} {}", pluralize!(n), match &trait_names[..] {
- [t] => t.to_string(),
- [ts @ .., last] => format!("{} and {last}", ts.join(", ")),
+ let trait_ = if all_known { format!("trait{}", pluralize!(n)) } else { String::new() };
+ format!("{stable}{trait_}{}", match &trait_names[..] {
+ [t] => format!(" {t}"),
+ [ts @ .., last] => format!(" {} and {last}", ts.join(", ")),
[] => return false,
},)
} else {
@@ -531,7 +531,7 @@ pub fn suggest_constraining_type_params<'a>(
let (span, post, suggestion, msg) = suggestions.pop().unwrap();
let msg = match msg {
SuggestChangingConstraintsMessage::RestrictBoundFurther => {
- format!("consider further restricting this bound with {post}")
+ format!("consider further restricting this bound")
}
SuggestChangingConstraintsMessage::RestrictTypeFurther { ty }
| SuggestChangingConstraintsMessage::RestrictType { ty }
diff --git a/tests/ui/associated-types/hr-associated-type-projection-1.stderr b/tests/ui/associated-types/hr-associated-type-projection-1.stderr
index c322d11925af2..b871bb51ae313 100644
--- a/tests/ui/associated-types/hr-associated-type-projection-1.stderr
+++ b/tests/ui/associated-types/hr-associated-type-projection-1.stderr
@@ -16,7 +16,7 @@ LL | trait UnsafeCopy<'a, T: Copy>
LL | where
LL | for<'b> <Self as UnsafeCopy<'b, T>>::Item: std::ops::Deref<Target = T>,
| ^^^^^^^^^^ required by this bound in `UnsafeCopy`
-help: consider further restricting this bound with `<Target = T>`
+help: consider further restricting this bound
|
LL | impl<T: Copy + std::ops::Deref<Target = T>> UnsafeCopy<'_, T> for T {
| ++++++++++++
diff --git a/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr b/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
index 16bfe2ec93373..ecb337bbceb91 100644
--- a/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
+++ b/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
@@ -13,7 +13,7 @@ note: required by a bound in `UnsafeCopy::Item`
|
LL | type Item<'a>: std::ops::Deref<Target = T>;
| ^^^^^^^^^^ required by this bound in `UnsafeCopy::Item`
-help: consider further restricting this bound with `<Target = T>`
+help: consider further restricting this bound
|
LL | impl<T: Copy + std::ops::Deref<Target = T>> UnsafeCopy<T> for T {
| ++++++++++++
diff --git a/tests/ui/generic-associated-types/missing-bounds.stderr b/tests/ui/generic-associated-types/missing-bounds.stderr
index c18cc3106f351..6e0700639e9c0 100644
--- a/tests/ui/generic-associated-types/missing-bounds.stderr
+++ b/tests/ui/generic-associated-types/missing-bounds.stderr
@@ -35,7 +35,7 @@ note: tuple struct defined here
|
LL | struct A<B>(B);
| ^
-help: consider further restricting this bound with `<Output = B>`
+help: consider further restricting this bound
|
LL | impl<B> Add for A<B> where B: Add<Output = B> {
| ++++++++++++
@@ -58,7 +58,7 @@ note: tuple struct defined here
|
LL | struct C<B>(B);
| ^
-help: consider further restricting this bound with `<Output = B>`
+help: consider further restricting this bound
|
LL | impl<B: Add<Output = B>> Add for C<B> {
| ++++++++++++
@@ -94,7 +94,7 @@ note: tuple struct defined here
|
LL | struct E<B>(B);
| ^
-help: consider further restricting this bound with `<Output = B>`
+help: consider further restricting this bound
|
LL | impl<B: Add<Output = B>> Add for E<B> where <B as Add>::Output = B {
| ++++++++++++
diff --git a/tests/ui/suggestions/restrict-existing-type-bounds.stderr b/tests/ui/suggestions/restrict-existing-type-bounds.stderr
index 45dab9bec5daa..fe8338c18c2bd 100644
--- a/tests/ui/suggestions/restrict-existing-type-bounds.stderr
+++ b/tests/ui/suggestions/restrict-existing-type-bounds.stderr
@@ -20,7 +20,7 @@ LL | Ok(self)
| this argument influences the type of `Ok`
note: tuple variant defined here
--> $SRC_DIR/core/src/result.rs:LL:COL
-help: consider further restricting this bound with `<Output = T>`
+help: consider further restricting this bound
|
LL | impl<T: TryAdd<Output = T>> TryAdd for Option<T> {
| ++++++++++++
@@ -47,7 +47,7 @@ LL | Ok(self)
| this argument influences the type of `Ok`
note: tuple variant defined here
--> $SRC_DIR/core/src/result.rs:LL:COL
-help: consider further restricting this bound with `, Output = T`
+help: consider further restricting this bound
|
LL | impl<T: TryAdd<Error = X, Output = T>> TryAdd for Other<T> {
| ++++++++++++
diff --git a/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr b/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
index ddadee3ea43fb..7aa32557af2de 100644
--- a/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
+++ b/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
@@ -11,7 +11,7 @@ LL | return a.bar();
= note: expected type parameter `B`
found associated type `<A as MyTrait>::T`
= note: the caller chooses a type for `B` which can be different from `<A as MyTrait>::T`
-help: consider further restricting this bound with `<T = B>`
+help: consider further restricting this bound
|
LL | pub fn foo<A: MyTrait<T = B>, B>(a: A) -> B {
| +++++++