bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Harmonize use of leaf and root obligation in trait error reporting

Browse source
This commit is contained in:
Michael Goulet 2024-06-08 14:02:01 -04:00
parent 8337ba9189
commit c453c82de4
12 changed files with 74 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

106
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View file

@ -412,8 +412,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let bound_predicate = obligation.predicate.kind(); let bound_predicate = obligation.predicate.kind();
match bound_predicate.skip_binder() { match bound_predicate.skip_binder() {
ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_predicate)) => { ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_predicate)) => {
let trait_predicate = bound_predicate.rebind(trait_predicate); let leaf_trait_predicate =
let trait_predicate = self.resolve_vars_if_possible(trait_predicate); self.resolve_vars_if_possible(bound_predicate.rebind(trait_predicate));
// Let's use the root obligation as the main message, when we care about the // Let's use the root obligation as the main message, when we care about the
// most general case ("X doesn't implement Pattern<'_>") over the case that // most general case ("X doesn't implement Pattern<'_>") over the case that
@ -424,7 +424,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let (main_trait_predicate, o) = if let ty::PredicateKind::Clause( let (main_trait_predicate, o) = if let ty::PredicateKind::Clause(
ty::ClauseKind::Trait(root_pred) ty::ClauseKind::Trait(root_pred)
) = root_obligation.predicate.kind().skip_binder() ) = root_obligation.predicate.kind().skip_binder()
&& !trait_predicate.self_ty().skip_binder().has_escaping_bound_vars() && !leaf_trait_predicate.self_ty().skip_binder().has_escaping_bound_vars()
&& !root_pred.self_ty().has_escaping_bound_vars() && !root_pred.self_ty().has_escaping_bound_vars()
// The type of the leaf predicate is (roughly) the same as the type // The type of the leaf predicate is (roughly) the same as the type
// from the root predicate, as a proxy for "we care about the root" // from the root predicate, as a proxy for "we care about the root"
@ -434,20 +434,20 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// `T: Trait` && `&&T: OtherTrait`, we want `OtherTrait` // `T: Trait` && `&&T: OtherTrait`, we want `OtherTrait`
self.can_eq( self.can_eq(
obligation.param_env, obligation.param_env,
trait_predicate.self_ty().skip_binder(), leaf_trait_predicate.self_ty().skip_binder(),
root_pred.self_ty().peel_refs(), root_pred.self_ty().peel_refs(),
) )
// `&str: Iterator` && `&str: IntoIterator`, we want `IntoIterator` // `&str: Iterator` && `&str: IntoIterator`, we want `IntoIterator`
|| self.can_eq( || self.can_eq(
obligation.param_env, obligation.param_env,
trait_predicate.self_ty().skip_binder(), leaf_trait_predicate.self_ty().skip_binder(),
root_pred.self_ty(), root_pred.self_ty(),
) )
) )
// The leaf trait and the root trait are different, so as to avoid // The leaf trait and the root trait are different, so as to avoid
// talking about `&mut T: Trait` and instead remain talking about // talking about `&mut T: Trait` and instead remain talking about
// `T: Trait` instead // `T: Trait` instead
&& trait_predicate.def_id() != root_pred.def_id() && leaf_trait_predicate.def_id() != root_pred.def_id()
// The root trait is not `Unsize`, as to avoid talking about it in // The root trait is not `Unsize`, as to avoid talking about it in
// `tests/ui/coercion/coerce-issue-49593-box-never.rs`. // `tests/ui/coercion/coerce-issue-49593-box-never.rs`.
&& Some(root_pred.def_id()) != self.tcx.lang_items().unsize_trait() && Some(root_pred.def_id()) != self.tcx.lang_items().unsize_trait()
@ -459,13 +459,14 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
root_obligation, root_obligation,
) )
} else { } else {
(trait_predicate, &obligation) (leaf_trait_predicate, &obligation)
}; };
let trait_ref = main_trait_predicate.to_poly_trait_ref(); let main_trait_ref = main_trait_predicate.to_poly_trait_ref();
let leaf_trait_ref = leaf_trait_predicate.to_poly_trait_ref();
if let Some(guar) = self.emit_specialized_closure_kind_error( if let Some(guar) = self.emit_specialized_closure_kind_error(
&obligation, &obligation,
trait_ref, leaf_trait_ref,
) { ) {
return guar; return guar;
} }
@ -473,7 +474,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// FIXME(effects) // FIXME(effects)
let predicate_is_const = false; let predicate_is_const = false;
if let Err(guar) = trait_predicate.error_reported() if let Err(guar) = leaf_trait_predicate.error_reported()
{ {
return guar; return guar;
} }
@ -507,16 +508,17 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
notes, notes,
parent_label, parent_label,
append_const_msg, append_const_msg,
} = self.on_unimplemented_note(trait_ref, o, &mut long_ty_file); } = self.on_unimplemented_note(main_trait_ref, o, &mut long_ty_file);
let have_alt_message = message.is_some() || label.is_some(); let have_alt_message = message.is_some() || label.is_some();
let is_try_conversion = self.is_try_conversion(span, trait_ref.def_id()); let is_try_conversion = self.is_try_conversion(span, main_trait_ref.def_id());
let is_unsize = let is_unsize =
Some(trait_ref.def_id()) == self.tcx.lang_items().unsize_trait(); Some(leaf_trait_ref.def_id()) == self.tcx.lang_items().unsize_trait();
let (message, notes, append_const_msg) = if is_try_conversion { let (message, notes, append_const_msg) = if is_try_conversion {
( (
Some(format!( Some(format!(
"`?` couldn't convert the error to `{}`", "`?` couldn't convert the error to `{}`",
trait_ref.skip_binder().self_ty(), main_trait_ref.skip_binder().self_ty(),
)), )),
vec![ vec![
"the question mark operation (`?`) implicitly performs a \ "the question mark operation (`?`) implicitly performs a \
@ -537,13 +539,13 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
post_message, post_message,
); );
let (err_msg, safe_transmute_explanation) = if Some(trait_ref.def_id()) let (err_msg, safe_transmute_explanation) = if Some(main_trait_ref.def_id())
== self.tcx.lang_items().transmute_trait() == self.tcx.lang_items().transmute_trait()
{ {
// Recompute the safe transmute reason and use that for the error reporting // Recompute the safe transmute reason and use that for the error reporting
match self.get_safe_transmute_error_and_reason( match self.get_safe_transmute_error_and_reason(
obligation.clone(), obligation.clone(),
trait_ref, main_trait_ref,
span, span,
) { ) {
GetSafeTransmuteErrorAndReason::Silent => { GetSafeTransmuteErrorAndReason::Silent => {
@ -571,7 +573,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
} }
let mut suggested = false; let mut suggested = false;
if is_try_conversion { if is_try_conversion {
suggested = self.try_conversion_context(&obligation, trait_ref.skip_binder(), &mut err); suggested = self.try_conversion_context(&obligation, main_trait_ref.skip_binder(), &mut err);
} }
if is_try_conversion && let Some(ret_span) = self.return_type_span(&obligation) { if is_try_conversion && let Some(ret_span) = self.return_type_span(&obligation) {
@ -579,19 +581,19 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
ret_span, ret_span,
format!( format!(
"expected `{}` because of this", "expected `{}` because of this",
trait_ref.skip_binder().self_ty() main_trait_ref.skip_binder().self_ty()
), ),
); );
} }
if Some(trait_ref.def_id()) == tcx.lang_items().tuple_trait() { if Some(leaf_trait_ref.def_id()) == tcx.lang_items().tuple_trait() {
self.add_tuple_trait_message( self.add_tuple_trait_message(
obligation.cause.code().peel_derives(), obligation.cause.code().peel_derives(),
&mut err, &mut err,
); );
} }
if Some(trait_ref.def_id()) == tcx.lang_items().drop_trait() if Some(leaf_trait_ref.def_id()) == tcx.lang_items().drop_trait()
&& predicate_is_const && predicate_is_const
{ {
err.note("`~const Drop` was renamed to `~const Destruct`"); err.note("`~const Drop` was renamed to `~const Destruct`");
@ -601,15 +603,15 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let explanation = get_explanation_based_on_obligation( let explanation = get_explanation_based_on_obligation(
self.tcx, self.tcx,
&obligation, &obligation,
trait_ref, leaf_trait_ref,
&trait_predicate, &leaf_trait_predicate,
pre_message, pre_message,
); );
self.check_for_binding_assigned_block_without_tail_expression( self.check_for_binding_assigned_block_without_tail_expression(
&obligation, &obligation,
&mut err, &mut err,
trait_predicate, leaf_trait_predicate,
); );
self.suggest_add_result_as_return_type(&obligation, self.suggest_add_result_as_return_type(&obligation,
&mut err, &mut err,
@ -618,7 +620,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if self.suggest_add_reference_to_arg( if self.suggest_add_reference_to_arg(
&obligation, &obligation,
&mut err, &mut err,
trait_predicate, leaf_trait_predicate,
have_alt_message, have_alt_message,
) { ) {
self.note_obligation_cause(&mut err, &obligation); self.note_obligation_cause(&mut err, &obligation);
@ -630,7 +632,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// If it has a custom `#[rustc_on_unimplemented]` // If it has a custom `#[rustc_on_unimplemented]`
// error message, let's display it as the label! // error message, let's display it as the label!
err.span_label(span, s); err.span_label(span, s);
if !matches!(trait_ref.skip_binder().self_ty().kind(), ty::Param(_)) { if !matches!(leaf_trait_ref.skip_binder().self_ty().kind(), ty::Param(_)) {
// When the self type is a type param We don't need to "the trait // When the self type is a type param We don't need to "the trait
// `std::marker::Sized` is not implemented for `T`" as we will point // `std::marker::Sized` is not implemented for `T`" as we will point
// at the type param with a label to suggest constraining it. // at the type param with a label to suggest constraining it.
@ -645,7 +647,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if let ObligationCauseCode::Coercion { source, target } = if let ObligationCauseCode::Coercion { source, target } =
*obligation.cause.code().peel_derives() *obligation.cause.code().peel_derives()
{ {
if Some(trait_ref.def_id()) == self.tcx.lang_items().sized_trait() { if Some(leaf_trait_ref.def_id()) == self.tcx.lang_items().sized_trait() {
self.suggest_borrowing_for_object_cast( self.suggest_borrowing_for_object_cast(
&mut err, &mut err,
root_obligation, root_obligation,
@ -657,7 +659,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let UnsatisfiedConst(unsatisfied_const) = self let UnsatisfiedConst(unsatisfied_const) = self
.maybe_add_note_for_unsatisfied_const( .maybe_add_note_for_unsatisfied_const(
&trait_predicate, &leaf_trait_predicate,
&mut err, &mut err,
span, span,
); );
@ -674,15 +676,15 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
err.span_label(tcx.def_span(body), s); err.span_label(tcx.def_span(body), s);
} }
self.suggest_floating_point_literal(&obligation, &mut err, &trait_ref); self.suggest_floating_point_literal(&obligation, &mut err, &leaf_trait_ref);
self.suggest_dereferencing_index(&obligation, &mut err, trait_predicate); self.suggest_dereferencing_index(&obligation, &mut err, leaf_trait_predicate);
suggested |= self.suggest_dereferences(&obligation, &mut err, trait_predicate); suggested |= self.suggest_dereferences(&obligation, &mut err, leaf_trait_predicate);
suggested |= self.suggest_fn_call(&obligation, &mut err, trait_predicate); suggested |= self.suggest_fn_call(&obligation, &mut err, leaf_trait_predicate);
let impl_candidates = self.find_similar_impl_candidates(trait_predicate); let impl_candidates = self.find_similar_impl_candidates(leaf_trait_predicate);
suggested = if let &[cand] = &impl_candidates[..] { suggested = if let &[cand] = &impl_candidates[..] {
let cand = cand.trait_ref; let cand = cand.trait_ref;
if let (ty::FnPtr(_), ty::FnDef(..)) = if let (ty::FnPtr(_), ty::FnDef(..)) =
(cand.self_ty().kind(), trait_ref.self_ty().skip_binder().kind()) (cand.self_ty().kind(), main_trait_ref.self_ty().skip_binder().kind())
{ {
err.span_suggestion( err.span_suggestion(
span.shrink_to_hi(), span.shrink_to_hi(),
@ -702,31 +704,31 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
false false
} || suggested; } || suggested;
suggested |= suggested |=
self.suggest_remove_reference(&obligation, &mut err, trait_predicate); self.suggest_remove_reference(&obligation, &mut err, leaf_trait_predicate);
suggested |= self.suggest_semicolon_removal( suggested |= self.suggest_semicolon_removal(
&obligation, &obligation,
&mut err, &mut err,
span, span,
trait_predicate, leaf_trait_predicate,
); );
self.note_version_mismatch(&mut err, &trait_ref); self.note_version_mismatch(&mut err, &leaf_trait_ref);
self.suggest_remove_await(&obligation, &mut err); self.suggest_remove_await(&obligation, &mut err);
self.suggest_derive(&obligation, &mut err, trait_predicate); self.suggest_derive(&obligation, &mut err, leaf_trait_predicate);
if Some(trait_ref.def_id()) == tcx.lang_items().try_trait() { if Some(leaf_trait_ref.def_id()) == tcx.lang_items().try_trait() {
self.suggest_await_before_try( self.suggest_await_before_try(
&mut err, &mut err,
&obligation, &obligation,
trait_predicate, leaf_trait_predicate,
span, span,
); );
} }
if self.suggest_add_clone_to_arg(&obligation, &mut err, trait_predicate) { if self.suggest_add_clone_to_arg(&obligation, &mut err, leaf_trait_predicate) {
return err.emit(); return err.emit();
} }
if self.suggest_impl_trait(&mut err, &obligation, trait_predicate) { if self.suggest_impl_trait(&mut err, &obligation, leaf_trait_predicate) {
return err.emit(); return err.emit();
} }
@ -741,9 +743,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
); );
} }
let is_fn_trait = tcx.is_fn_trait(trait_ref.def_id()); let is_fn_trait = tcx.is_fn_trait(leaf_trait_ref.def_id());
let is_target_feature_fn = if let ty::FnDef(def_id, _) = let is_target_feature_fn = if let ty::FnDef(def_id, _) =
*trait_ref.skip_binder().self_ty().kind() *leaf_trait_ref.skip_binder().self_ty().kind()
{ {
!self.tcx.codegen_fn_attrs(def_id).target_features.is_empty() !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty()
} else { } else {
@ -757,8 +759,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
self.try_to_add_help_message( self.try_to_add_help_message(
&obligation, &obligation,
trait_ref, leaf_trait_ref,
&trait_predicate, &leaf_trait_predicate,
&mut err, &mut err,
span, span,
is_fn_trait, is_fn_trait,
@ -769,17 +771,17 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// Changing mutability doesn't make a difference to whether we have // Changing mutability doesn't make a difference to whether we have
// an `Unsize` impl (Fixes ICE in #71036) // an `Unsize` impl (Fixes ICE in #71036)
if !is_unsize { if !is_unsize {
self.suggest_change_mut(&obligation, &mut err, trait_predicate); self.suggest_change_mut(&obligation, &mut err, leaf_trait_predicate);
} }
// If this error is due to `!: Trait` not implemented but `(): Trait` is // If this error is due to `!: Trait` not implemented but `(): Trait` is
// implemented, and fallback has occurred, then it could be due to a // implemented, and fallback has occurred, then it could be due to a
// variable that used to fallback to `()` now falling back to `!`. Issue a // variable that used to fallback to `()` now falling back to `!`. Issue a
// note informing about the change in behaviour. // note informing about the change in behaviour.
if trait_predicate.skip_binder().self_ty().is_never() if leaf_trait_predicate.skip_binder().self_ty().is_never()
&& self.fallback_has_occurred && self.fallback_has_occurred
{ {
let predicate = trait_predicate.map_bound(|trait_pred| { let predicate = leaf_trait_predicate.map_bound(|trait_pred| {
trait_pred.with_self_ty(self.tcx, tcx.types.unit) trait_pred.with_self_ty(self.tcx, tcx.types.unit)
}); });
let unit_obligation = obligation.with(tcx, predicate); let unit_obligation = obligation.with(tcx, predicate);
@ -794,8 +796,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
} }
} }
self.explain_hrtb_projection(&mut err, trait_predicate, obligation.param_env, &obligation.cause); self.explain_hrtb_projection(&mut err, leaf_trait_predicate, obligation.param_env, &obligation.cause);
self.suggest_desugaring_async_fn_in_trait(&mut err, trait_ref); self.suggest_desugaring_async_fn_in_trait(&mut err, main_trait_ref);
// Return early if the trait is Debug or Display and the invocation // Return early if the trait is Debug or Display and the invocation
// originates within a standard library macro, because the output // originates within a standard library macro, because the output
@ -813,15 +815,13 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if in_std_macro if in_std_macro
&& matches!( && matches!(
self.tcx.get_diagnostic_name(trait_ref.def_id()), self.tcx.get_diagnostic_name(leaf_trait_ref.def_id()),
Some(sym::Debug | sym::Display) Some(sym::Debug | sym::Display)
) )
{ {
return err.emit(); return err.emit();
} }
err err
} }

2
tests/ui/auto-traits/typeck-default-trait-impl-precedence.stderr
View file

@ -2,7 +2,7 @@ error[E0277]: the trait bound `&'static u32: Defaulted` is not satisfied
--> $DIR/typeck-default-trait-impl-precedence.rs:19:20 --> $DIR/typeck-default-trait-impl-precedence.rs:19:20
| |
LL | is_defaulted::<&'static u32>(); LL | is_defaulted::<&'static u32>();
| ^^^^^^^^^^^^ the trait `Signed` is not implemented for `&'static u32`, which is required by `&'static u32: Defaulted` | ^^^^^^^^^^^^ the trait `Signed` is not implemented for `u32`, which is required by `&'static u32: Defaulted`
| |
note: required for `&'static u32` to implement `Defaulted` note: required for `&'static u32` to implement `Defaulted`
--> $DIR/typeck-default-trait-impl-precedence.rs:10:19 --> $DIR/typeck-default-trait-impl-precedence.rs:10:19

2
tests/ui/generic-associated-types/assume-gat-normalization-for-nested-goals.next.stderr
View file

@ -2,7 +2,7 @@ error[E0277]: the trait bound `i32: Baz<Self>` is not satisfied
--> $DIR/assume-gat-normalization-for-nested-goals.rs:9:30 --> $DIR/assume-gat-normalization-for-nested-goals.rs:9:30
| |
LL | type Bar<T>: Baz<Self> = i32; LL | type Bar<T>: Baz<Self> = i32;
| ^^^ the trait `Eq<i32>` is not implemented for `i32`, which is required by `i32: Baz<Self>` | ^^^ the trait `Eq<i32>` is not implemented for `<Self as Foo>::Bar<()>`, which is required by `i32: Baz<Self>`
| |
note: required for `i32` to implement `Baz<Self>` note: required for `i32` to implement `Baz<Self>`
--> $DIR/assume-gat-normalization-for-nested-goals.rs:16:23 --> $DIR/assume-gat-normalization-for-nested-goals.rs:16:23

2
tests/ui/kindck/kindck-send-object.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: `&'static (dyn Dummy + 'static)` cannot be sent between threads sa
LL | assert_send::<&'static (dyn Dummy + 'static)>(); LL | assert_send::<&'static (dyn Dummy + 'static)>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&'static (dyn Dummy + 'static)` cannot be sent between threads safely | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
| |
= help: the trait `Sync` is not implemented for `&'static (dyn Dummy + 'static)`, which is required by `&'static (dyn Dummy + 'static): Send` = help: the trait `Sync` is not implemented for `(dyn Dummy + 'static)`, which is required by `&'static (dyn Dummy + 'static): Send`
= note: required for `&'static (dyn Dummy + 'static)` to implement `Send` = note: required for `&'static (dyn Dummy + 'static)` to implement `Send`
note: required by a bound in `assert_send` note: required by a bound in `assert_send`
--> $DIR/kindck-send-object.rs:5:18 --> $DIR/kindck-send-object.rs:5:18

2
tests/ui/kindck/kindck-send-object1.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: `&'a (dyn Dummy + 'a)` cannot be sent between threads safely
LL | assert_send::<&'a dyn Dummy>(); LL | assert_send::<&'a dyn Dummy>();
| ^^^^^^^^^^^^^ `&'a (dyn Dummy + 'a)` cannot be sent between threads safely | ^^^^^^^^^^^^^ `&'a (dyn Dummy + 'a)` cannot be sent between threads safely
| |
= help: the trait `Sync` is not implemented for `&'a (dyn Dummy + 'a)`, which is required by `&'a (dyn Dummy + 'a): Send` = help: the trait `Sync` is not implemented for `(dyn Dummy + 'a)`, which is required by `&'a (dyn Dummy + 'a): Send`
= note: required for `&'a (dyn Dummy + 'a)` to implement `Send` = note: required for `&'a (dyn Dummy + 'a)` to implement `Send`
note: required by a bound in `assert_send` note: required by a bound in `assert_send`
--> $DIR/kindck-send-object1.rs:5:18 --> $DIR/kindck-send-object1.rs:5:18

2
tests/ui/kindck/kindck-send-object2.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: `&'static (dyn Dummy + 'static)` cannot be sent between threads sa
LL | assert_send::<&'static dyn Dummy>(); LL | assert_send::<&'static dyn Dummy>();
| ^^^^^^^^^^^^^^^^^^ `&'static (dyn Dummy + 'static)` cannot be sent between threads safely | ^^^^^^^^^^^^^^^^^^ `&'static (dyn Dummy + 'static)` cannot be sent between threads safely
| |
= help: the trait `Sync` is not implemented for `&'static (dyn Dummy + 'static)`, which is required by `&'static (dyn Dummy + 'static): Send` = help: the trait `Sync` is not implemented for `(dyn Dummy + 'static)`, which is required by `&'static (dyn Dummy + 'static): Send`
= note: required for `&'static (dyn Dummy + 'static)` to implement `Send` = note: required for `&'static (dyn Dummy + 'static)` to implement `Send`
note: required by a bound in `assert_send` note: required by a bound in `assert_send`
--> $DIR/kindck-send-object2.rs:3:18 --> $DIR/kindck-send-object2.rs:3:18

4
tests/ui/suggestions/suggest-remove-refs-5.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: `&mut &mut &mut &mut Vec<i32>` is not an iterator
LL | for _ in &mut &mut v {} LL | for _ in &mut &mut v {}
| ^^^^^^^^^^^ `&mut &mut &mut &mut Vec<i32>` is not an iterator | ^^^^^^^^^^^ `&mut &mut &mut &mut Vec<i32>` is not an iterator
| |
= help: the trait `Iterator` is not implemented for `&mut &mut &mut &mut Vec<i32>`, which is required by `&mut &mut &mut &mut Vec<i32>: IntoIterator` = help: the trait `Iterator` is not implemented for `Vec<i32>`, which is required by `&mut &mut &mut &mut Vec<i32>: IntoIterator`
= note: required for `&mut Vec<i32>` to implement `Iterator` = note: required for `&mut Vec<i32>` to implement `Iterator`
= note: 3 redundant requirements hidden = note: 3 redundant requirements hidden
= note: required for `&mut &mut &mut &mut Vec<i32>` to implement `Iterator` = note: required for `&mut &mut &mut &mut Vec<i32>` to implement `Iterator`
@ -21,7 +21,7 @@ error[E0277]: `&mut &mut &mut [u8; 1]` is not an iterator
LL | for _ in &mut v {} LL | for _ in &mut v {}
| ^^^^^^ `&mut &mut &mut [u8; 1]` is not an iterator | ^^^^^^ `&mut &mut &mut [u8; 1]` is not an iterator
| |
= help: the trait `Iterator` is not implemented for `&mut &mut &mut [u8; 1]`, which is required by `&mut &mut &mut [u8; 1]: IntoIterator` = help: the trait `Iterator` is not implemented for `[u8; 1]`, which is required by `&mut &mut &mut [u8; 1]: IntoIterator`
= note: required for `&mut [u8; 1]` to implement `Iterator` = note: required for `&mut [u8; 1]` to implement `Iterator`
= note: 2 redundant requirements hidden = note: 2 redundant requirements hidden
= note: required for `&mut &mut &mut [u8; 1]` to implement `Iterator` = note: required for `&mut &mut &mut [u8; 1]` to implement `Iterator`

2
tests/ui/traits/next-solver/auto-with-drop_tracking_mir.fail.stderr
View file

@ -4,7 +4,7 @@ error: future cannot be sent between threads safely
LL | is_send(foo()); LL | is_send(foo());
| ^^^^^ future returned by `foo` is not `Send` | ^^^^^ future returned by `foo` is not `Send`
| |
= help: the trait `Sync` is not implemented for `impl Future<Output = ()>`, which is required by `impl Future<Output = ()>: Send` = help: the trait `Sync` is not implemented for `NotSync`, which is required by `impl Future<Output = ()>: Send`
note: future is not `Send` as this value is used across an await note: future is not `Send` as this value is used across an await
--> $DIR/auto-with-drop_tracking_mir.rs:16:11 --> $DIR/auto-with-drop_tracking_mir.rs:16:11
| |

5
tests/ui/traits/next-solver/diagnostics/point-at-failing-nested.stderr
View file

@ -4,6 +4,11 @@ error[E0277]: the trait bound `(): Foo` is not satisfied
LL | needs_foo::<()>(); LL | needs_foo::<()>();
| ^^ the trait `Bar` is not implemented for `()`, which is required by `(): Foo` | ^^ the trait `Bar` is not implemented for `()`, which is required by `(): Foo`
| |
help: this trait has no implementations, consider adding one
--> $DIR/point-at-failing-nested.rs:4:1
|
LL | trait Bar {}
| ^^^^^^^^^
note: required for `()` to implement `Foo` note: required for `()` to implement `Foo`
--> $DIR/point-at-failing-nested.rs:9:12 --> $DIR/point-at-failing-nested.rs:9:12
| |

5
tests/ui/traits/next-solver/diagnostics/where-clause-doesnt-apply.stderr
View file

@ -6,6 +6,11 @@ LL | needs_foo(());
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |
help: this trait has no implementations, consider adding one
--> $DIR/where-clause-doesnt-apply.rs:2:1
|
LL | trait Bar {}
| ^^^^^^^^^
note: required for `()` to implement `Foo` note: required for `()` to implement `Foo`
--> $DIR/where-clause-doesnt-apply.rs:4:9 --> $DIR/where-clause-doesnt-apply.rs:4:9
| |

2
tests/ui/traits/suggest-dereferences/root-obligation.stderr
View file

@ -2,7 +2,7 @@ error[E0277]: the trait bound `&char: Pattern<'_>` is not satisfied
--> $DIR/root-obligation.rs:6:38 --> $DIR/root-obligation.rs:6:38
| |
LL | .filter(|c| "aeiou".contains(c)) LL | .filter(|c| "aeiou".contains(c))
| -------- ^ the trait `Fn(char)` is not implemented for `&char`, which is required by `&char: Pattern<'_>` | -------- ^ the trait `Fn(char)` is not implemented for `char`, which is required by `&char: Pattern<'_>`
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |

4
tests/ui/transmutability/references/unsafecell.stderr
View file

@ -2,7 +2,7 @@ error[E0277]: `&u8` cannot be safely transmuted into `&UnsafeCell<u8>`
--> $DIR/unsafecell.rs:27:50 --> $DIR/unsafecell.rs:27:50
| |
LL | assert::is_maybe_transmutable::<&'static u8, &'static UnsafeCell<u8>>(); LL | assert::is_maybe_transmutable::<&'static u8, &'static UnsafeCell<u8>>();
| ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Freeze` is not implemented for `&'static UnsafeCell<u8>` | ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Freeze` is not implemented for `UnsafeCell<u8>`
| |
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/unsafecell.rs:12:14 --> $DIR/unsafecell.rs:12:14
@ -17,7 +17,7 @@ error[E0277]: `&UnsafeCell<u8>` cannot be safely transmuted into `&UnsafeCell<u8
--> $DIR/unsafecell.rs:29:62 --> $DIR/unsafecell.rs:29:62
| |
LL | assert::is_maybe_transmutable::<&'static UnsafeCell<u8>, &'static UnsafeCell<u8>>(); LL | assert::is_maybe_transmutable::<&'static UnsafeCell<u8>, &'static UnsafeCell<u8>>();
| ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Freeze` is not implemented for `&'static UnsafeCell<u8>` | ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Freeze` is not implemented for `UnsafeCell<u8>`
| |
note: required by a bound in `is_maybe_transmutable` note: required by a bound in `is_maybe_transmutable`
--> $DIR/unsafecell.rs:12:14 --> $DIR/unsafecell.rs:12:14