nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-28 17:53:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Don't call const normalize in error reporting

Browse Source
This commit is contained in:
Michael Goulet 2024-09-22 13:52:20 -04:00
parent 0af7f0f4c4
commit 8f579497f7
30 changed files with 177 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
View File

@ -17,7 +17,7 @@ use rustc_middle::traits::select::OverflowError;
use rustc_middle::traits::SignatureMismatchData; use rustc_middle::traits::SignatureMismatchData;
use rustc_middle::ty::abstract_const::NotConstEvaluatable; use rustc_middle::ty::abstract_const::NotConstEvaluatable;
use rustc_middle::ty::error::{ExpectedFound, TypeError}; use rustc_middle::ty::error::{ExpectedFound, TypeError};
use rustc_middle::ty::fold::{BottomUpFolder, TypeFolder, TypeSuperFoldable}; use rustc_middle::ty::fold::{TypeFolder, TypeSuperFoldable};
use rustc_middle::ty::print::{ use rustc_middle::ty::print::{
with_forced_trimmed_paths, FmtPrinter, Print, PrintTraitPredicateExt as _, with_forced_trimmed_paths, FmtPrinter, Print, PrintTraitPredicateExt as _,
PrintTraitRefExt as _, PrintTraitRefExt as _,
@ -1794,22 +1794,18 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
return false; return false;
} }
let cand = self.resolve_vars_if_possible(impl_trait_ref).fold_with( let impl_trait_ref = self.resolve_vars_if_possible(impl_trait_ref);
&mut BottomUpFolder { if impl_trait_ref.references_error() {
tcx: self.tcx,
ty_op: |ty| ty,
lt_op: |lt| lt,
ct_op: |ct| ct.normalize(self.tcx, ty::ParamEnv::empty()),
},
);
if cand.references_error() {
return false; return false;
} }
err.highlighted_help(vec![ err.highlighted_help(vec![
StringPart::normal(format!("the trait `{}` ", cand.print_trait_sugared())), StringPart::normal(format!(
"the trait `{}` ",
impl_trait_ref.print_trait_sugared()
)),
StringPart::highlighted("is"), StringPart::highlighted("is"),
StringPart::normal(" implemented for `"), StringPart::normal(" implemented for `"),
StringPart::highlighted(cand.self_ty().to_string()), StringPart::highlighted(impl_trait_ref.self_ty().to_string()),
StringPart::normal("`"), StringPart::normal("`"),
]); ]);
@ -1921,15 +1917,18 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
let mut impl_candidates: Vec<_> = impl_candidates let mut impl_candidates: Vec<_> = impl_candidates
.iter() .iter()
.cloned() .cloned()
.filter(|cand| !cand.trait_ref.references_error())
.map(|mut cand| { .map(|mut cand| {
// Fold the consts so that they shows up as, e.g., `10` // Normalize the trait ref in its *own* param-env so
// instead of `core::::array::{impl#30}::{constant#0}`. // that consts are folded and any trivial projections
cand.trait_ref = cand.trait_ref.fold_with(&mut BottomUpFolder { // are normalized.
tcx: self.tcx, cand.trait_ref = self
ty_op: |ty| ty, .tcx
lt_op: |lt| lt, .try_normalize_erasing_regions(
ct_op: |ct| ct.normalize(self.tcx, ty::ParamEnv::empty()), self.tcx.param_env(cand.impl_def_id),
}); cand.trait_ref,
)
.unwrap_or(cand.trait_ref);
cand cand
}) })
.collect(); .collect();

4
tests/ui/binop/binary-op-suggest-deref.stderr
View File

@ -303,8 +303,8 @@ LL | let _ = FOO & (*"Sized".to_string().into_boxed_str());
| |
= help: the trait `BitAnd<str>` is not implemented for `i32` = help: the trait `BitAnd<str>` is not implemented for `i32`
= help: the following other types implement trait `BitAnd<Rhs>`: = help: the following other types implement trait `BitAnd<Rhs>`:
`&'a i32` implements `BitAnd<i32>` `&i32` implements `BitAnd<i32>`
`&i32` implements `BitAnd<&i32>` `&i32` implements `BitAnd`
`i32` implements `BitAnd<&i32>` `i32` implements `BitAnd<&i32>`
`i32` implements `BitAnd` `i32` implements `BitAnd`

4
tests/ui/binop/binop-mul-i32-f32.stderr
View File

@ -6,8 +6,8 @@ LL | x * y
| |
= help: the trait `Mul<f32>` is not implemented for `i32` = help: the trait `Mul<f32>` is not implemented for `i32`
= help: the following other types implement trait `Mul<Rhs>`: = help: the following other types implement trait `Mul<Rhs>`:
`&'a i32` implements `Mul<i32>` `&i32` implements `Mul<i32>`
`&i32` implements `Mul<&i32>` `&i32` implements `Mul`
`i32` implements `Mul<&i32>` `i32` implements `Mul<&i32>`
`i32` implements `Mul` `i32` implements `Mul`

48
tests/ui/binop/shift-various-bad-types.stderr
View File

@ -6,14 +6,14 @@ LL | 22 >> p.char;
| |
= help: the trait `Shr<char>` is not implemented for `{integer}` = help: the trait `Shr<char>` is not implemented for `{integer}`
= help: the following other types implement trait `Shr<Rhs>`: = help: the following other types implement trait `Shr<Rhs>`:
`&'a i128` implements `Shr<i128>` `&i128` implements `Shr<&i16>`
`&'a i128` implements `Shr<i16>` `&i128` implements `Shr<&i32>`
`&'a i128` implements `Shr<i32>` `&i128` implements `Shr<&i64>`
`&'a i128` implements `Shr<i64>` `&i128` implements `Shr<&i8>`
`&'a i128` implements `Shr<i8>` `&i128` implements `Shr<&isize>`
`&'a i128` implements `Shr<isize>` `&i128` implements `Shr<&u128>`
`&'a i128` implements `Shr<u128>` `&i128` implements `Shr<&u16>`
`&'a i128` implements `Shr<u16>` `&i128` implements `Shr<&u32>`
and 568 others and 568 others
error[E0277]: no implementation for `{integer} >> &str` error[E0277]: no implementation for `{integer} >> &str`
@ -24,14 +24,14 @@ LL | 22 >> p.str;
| |
= help: the trait `Shr<&str>` is not implemented for `{integer}` = help: the trait `Shr<&str>` is not implemented for `{integer}`
= help: the following other types implement trait `Shr<Rhs>`: = help: the following other types implement trait `Shr<Rhs>`:
`&'a i128` implements `Shr<i128>` `&i128` implements `Shr<&i16>`
`&'a i128` implements `Shr<i16>` `&i128` implements `Shr<&i32>`
`&'a i128` implements `Shr<i32>` `&i128` implements `Shr<&i64>`
`&'a i128` implements `Shr<i64>` `&i128` implements `Shr<&i8>`
`&'a i128` implements `Shr<i8>` `&i128` implements `Shr<&isize>`
`&'a i128` implements `Shr<isize>` `&i128` implements `Shr<&u128>`
`&'a i128` implements `Shr<u128>` `&i128` implements `Shr<&u16>`
`&'a i128` implements `Shr<u16>` `&i128` implements `Shr<&u32>`
and 568 others and 568 others
error[E0277]: no implementation for `{integer} >> &Panolpy` error[E0277]: no implementation for `{integer} >> &Panolpy`
@ -42,14 +42,14 @@ LL | 22 >> p;
| |
= help: the trait `Shr<&Panolpy>` is not implemented for `{integer}` = help: the trait `Shr<&Panolpy>` is not implemented for `{integer}`
= help: the following other types implement trait `Shr<Rhs>`: = help: the following other types implement trait `Shr<Rhs>`:
`&'a i128` implements `Shr<i128>` `&i128` implements `Shr<&i16>`
`&'a i128` implements `Shr<i16>` `&i128` implements `Shr<&i32>`
`&'a i128` implements `Shr<i32>` `&i128` implements `Shr<&i64>`
`&'a i128` implements `Shr<i64>` `&i128` implements `Shr<&i8>`
`&'a i128` implements `Shr<i8>` `&i128` implements `Shr<&isize>`
`&'a i128` implements `Shr<isize>` `&i128` implements `Shr<&u128>`
`&'a i128` implements `Shr<u128>` `&i128` implements `Shr<&u16>`
`&'a i128` implements `Shr<u16>` `&i128` implements `Shr<&u32>`
and 568 others and 568 others
error[E0308]: mismatched types error[E0308]: mismatched types

2
tests/ui/const-generics/occurs-check/unused-substs-1.stderr
View File

@ -4,7 +4,7 @@ error[E0277]: the trait bound `A<_>: Bar<_>` is not satisfied
LL | let _ = A; LL | let _ = A;
| ^ the trait `Bar<_>` is not implemented for `A<_>` | ^ the trait `Bar<_>` is not implemented for `A<_>`
| |
= help: the trait `Bar<_>` is implemented for `A<7>` = help: the trait `Bar<_>` is implemented for `A<{ 6 + 1 }>`
note: required by a bound in `A` note: required by a bound in `A`
--> $DIR/unused-substs-1.rs:9:11 --> $DIR/unused-substs-1.rs:9:11
| |

4
tests/ui/consts/const-eval/const-eval-overflow-3b.stderr
View File

@ -12,8 +12,8 @@ LL | = [0; (i8::MAX + 1u8) as usize];
| |
= help: the trait `Add<u8>` is not implemented for `i8` = help: the trait `Add<u8>` is not implemented for `i8`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a i8` implements `Add<i8>` `&i8` implements `Add<i8>`
`&i8` implements `Add<&i8>` `&i8` implements `Add`
`i8` implements `Add<&i8>` `i8` implements `Add<&i8>`
`i8` implements `Add` `i8` implements `Add`

4
tests/ui/consts/const-eval/const-eval-overflow-4b.stderr
View File

@ -12,8 +12,8 @@ LL | : [u32; (i8::MAX as i8 + 1u8) as usize]
| |
= help: the trait `Add<u8>` is not implemented for `i8` = help: the trait `Add<u8>` is not implemented for `i8`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a i8` implements `Add<i8>` `&i8` implements `Add<i8>`
`&i8` implements `Add<&i8>` `&i8` implements `Add`
`i8` implements `Add<&i8>` `i8` implements `Add<&i8>`
`i8` implements `Add` `i8` implements `Add`

4
tests/ui/impl-trait/equality.stderr
View File

@ -30,8 +30,8 @@ LL | n + sum_to(n - 1)
| |
= help: the trait `Add<impl Foo>` is not implemented for `u32` = help: the trait `Add<impl Foo>` is not implemented for `u32`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a u32` implements `Add<u32>` `&u32` implements `Add<u32>`
`&u32` implements `Add<&u32>` `&u32` implements `Add`
`u32` implements `Add<&u32>` `u32` implements `Add<&u32>`
`u32` implements `Add` `u32` implements `Add`

32
tests/ui/issues/issue-11771.stderr
View File

@ -6,14 +6,14 @@ LL | 1 +
| |
= help: the trait `Add<()>` is not implemented for `{integer}` = help: the trait `Add<()>` is not implemented for `{integer}`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a f128` implements `Add<f128>` `&f128` implements `Add<f128>`
`&'a f16` implements `Add<f16>` `&f128` implements `Add`
`&'a f32` implements `Add<f32>` `&f16` implements `Add<f16>`
`&'a f64` implements `Add<f64>` `&f16` implements `Add`
`&'a i128` implements `Add<i128>` `&f32` implements `Add<f32>`
`&'a i16` implements `Add<i16>` `&f32` implements `Add`
`&'a i32` implements `Add<i32>` `&f64` implements `Add<f64>`
`&'a i64` implements `Add<i64>` `&f64` implements `Add`
and 56 others and 56 others
error[E0277]: cannot add `()` to `{integer}` error[E0277]: cannot add `()` to `{integer}`
@ -24,14 +24,14 @@ LL | 1 +
| |
= help: the trait `Add<()>` is not implemented for `{integer}` = help: the trait `Add<()>` is not implemented for `{integer}`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a f128` implements `Add<f128>` `&f128` implements `Add<f128>`
`&'a f16` implements `Add<f16>` `&f128` implements `Add`
`&'a f32` implements `Add<f32>` `&f16` implements `Add<f16>`
`&'a f64` implements `Add<f64>` `&f16` implements `Add`
`&'a i128` implements `Add<i128>` `&f32` implements `Add<f32>`
`&'a i16` implements `Add<i16>` `&f32` implements `Add`
`&'a i32` implements `Add<i32>` `&f64` implements `Add<f64>`
`&'a i64` implements `Add<i64>` `&f64` implements `Add`
and 56 others and 56 others
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

4
tests/ui/issues/issue-24352.stderr
View File

@ -6,8 +6,8 @@ LL | 1.0f64 - 1
| |
= help: the trait `Sub<{integer}>` is not implemented for `f64` = help: the trait `Sub<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Sub<Rhs>`: = help: the following other types implement trait `Sub<Rhs>`:
`&'a f64` implements `Sub<f64>` `&f64` implements `Sub<f64>`
`&f64` implements `Sub<&f64>` `&f64` implements `Sub`
`f64` implements `Sub<&f64>` `f64` implements `Sub<&f64>`
`f64` implements `Sub` `f64` implements `Sub`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`

16
tests/ui/issues/issue-50582.stderr
View File

@ -16,14 +16,14 @@ LL | Vec::<[(); 1 + for x in 0..1 {}]>::new();
| |
= help: the trait `Add<()>` is not implemented for `{integer}` = help: the trait `Add<()>` is not implemented for `{integer}`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a f128` implements `Add<f128>` `&f128` implements `Add<f128>`
`&'a f16` implements `Add<f16>` `&f128` implements `Add`
`&'a f32` implements `Add<f32>` `&f16` implements `Add<f16>`
`&'a f64` implements `Add<f64>` `&f16` implements `Add`
`&'a i128` implements `Add<i128>` `&f32` implements `Add<f32>`
`&'a i16` implements `Add<i16>` `&f32` implements `Add`
`&'a i32` implements `Add<i32>` `&f64` implements `Add<f64>`
`&'a i64` implements `Add<i64>` `&f64` implements `Add`
and 56 others and 56 others
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

6
tests/ui/iterators/invalid-iterator-chain-fixable.stderr
View File

@ -33,7 +33,7 @@ LL | println!("{}", scores.sum::<i32>());
| |
= help: the trait `Sum<()>` is not implemented for `i32` = help: the trait `Sum<()>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain-fixable.rs:14:10 --> $DIR/invalid-iterator-chain-fixable.rs:14:10
@ -66,7 +66,7 @@ LL | .sum::<i32>(),
| |
= help: the trait `Sum<()>` is not implemented for `i32` = help: the trait `Sum<()>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain-fixable.rs:23:14 --> $DIR/invalid-iterator-chain-fixable.rs:23:14
@ -99,7 +99,7 @@ LL | println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
| |
= help: the trait `Sum<()>` is not implemented for `i32` = help: the trait `Sum<()>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain-fixable.rs:27:38 --> $DIR/invalid-iterator-chain-fixable.rs:27:38

2
tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr
View File

@ -8,7 +8,7 @@ LL | let x = Some(()).iter().map(|()| 1).sum::<f32>();
| |
= help: the trait `Sum<{integer}>` is not implemented for `f32` = help: the trait `Sum<{integer}>` is not implemented for `f32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`f32` implements `Sum<&'a f32>` `f32` implements `Sum<&f32>`
`f32` implements `Sum` `f32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain-with-int-infer.rs:2:29 --> $DIR/invalid-iterator-chain-with-int-infer.rs:2:29

10
tests/ui/iterators/invalid-iterator-chain.stderr
View File

@ -33,7 +33,7 @@ LL | println!("{}", scores.sum::<i32>());
| |
= help: the trait `Sum<()>` is not implemented for `i32` = help: the trait `Sum<()>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain.rs:12:10 --> $DIR/invalid-iterator-chain.rs:12:10
@ -65,7 +65,7 @@ LL | .sum::<i32>(),
| |
= help: the trait `Sum<()>` is not implemented for `i32` = help: the trait `Sum<()>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain.rs:25:14 --> $DIR/invalid-iterator-chain.rs:25:14
@ -104,7 +104,7 @@ LL | .sum::<i32>(),
| |
= help: the trait `Sum<f64>` is not implemented for `i32` = help: the trait `Sum<f64>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain.rs:33:14 --> $DIR/invalid-iterator-chain.rs:33:14
@ -134,7 +134,7 @@ LL | println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
| |
= help: the trait `Sum<()>` is not implemented for `i32` = help: the trait `Sum<()>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain.rs:38:38 --> $DIR/invalid-iterator-chain.rs:38:38
@ -162,7 +162,7 @@ LL | println!("{}", vec![(), ()].iter().sum::<i32>());
| |
= help: the trait `Sum<&()>` is not implemented for `i32` = help: the trait `Sum<&()>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/invalid-iterator-chain.rs:39:33 --> $DIR/invalid-iterator-chain.rs:39:33

2
tests/ui/lazy-type-alias/trailing-where-clause.stderr
View File

@ -9,7 +9,7 @@ LL | let _: Alias<()>;
`String` implements `From<&mut str>` `String` implements `From<&mut str>`
`String` implements `From<&str>` `String` implements `From<&str>`
`String` implements `From<Box<str>>` `String` implements `From<Box<str>>`
`String` implements `From<Cow<'a, str>>` `String` implements `From<Cow<'_, str>>`
`String` implements `From<char>` `String` implements `From<char>`
note: required by a bound in `Alias` note: required by a bound in `Alias`
--> $DIR/trailing-where-clause.rs:8:13 --> $DIR/trailing-where-clause.rs:8:13

52
tests/ui/mismatched_types/binops.stderr
View File

@ -6,14 +6,14 @@ LL | 1 + Some(1);
| |
= help: the trait `Add<Option<{integer}>>` is not implemented for `{integer}` = help: the trait `Add<Option<{integer}>>` is not implemented for `{integer}`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a f128` implements `Add<f128>` `&f128` implements `Add<f128>`
`&'a f16` implements `Add<f16>` `&f128` implements `Add`
`&'a f32` implements `Add<f32>` `&f16` implements `Add<f16>`
`&'a f64` implements `Add<f64>` `&f16` implements `Add`
`&'a i128` implements `Add<i128>` `&f32` implements `Add<f32>`
`&'a i16` implements `Add<i16>` `&f32` implements `Add`
`&'a i32` implements `Add<i32>` `&f64` implements `Add<f64>`
`&'a i64` implements `Add<i64>` `&f64` implements `Add`
and 56 others and 56 others
error[E0277]: cannot subtract `Option<{integer}>` from `usize` error[E0277]: cannot subtract `Option<{integer}>` from `usize`
@ -24,8 +24,8 @@ LL | 2 as usize - Some(1);
| |
= help: the trait `Sub<Option<{integer}>>` is not implemented for `usize` = help: the trait `Sub<Option<{integer}>>` is not implemented for `usize`
= help: the following other types implement trait `Sub<Rhs>`: = help: the following other types implement trait `Sub<Rhs>`:
`&'a usize` implements `Sub<usize>` `&usize` implements `Sub<usize>`
`&usize` implements `Sub<&usize>` `&usize` implements `Sub`
`usize` implements `Sub<&usize>` `usize` implements `Sub<&usize>`
`usize` implements `Sub` `usize` implements `Sub`
@ -37,14 +37,14 @@ LL | 3 * ();
| |
= help: the trait `Mul<()>` is not implemented for `{integer}` = help: the trait `Mul<()>` is not implemented for `{integer}`
= help: the following other types implement trait `Mul<Rhs>`: = help: the following other types implement trait `Mul<Rhs>`:
`&'a f128` implements `Mul<f128>` `&f128` implements `Mul<f128>`
`&'a f16` implements `Mul<f16>` `&f128` implements `Mul`
`&'a f32` implements `Mul<f32>` `&f16` implements `Mul<f16>`
`&'a f64` implements `Mul<f64>` `&f16` implements `Mul`
`&'a i128` implements `Mul<i128>` `&f32` implements `Mul<f32>`
`&'a i16` implements `Mul<i16>` `&f32` implements `Mul`
`&'a i32` implements `Mul<i32>` `&f64` implements `Mul<f64>`
`&'a i64` implements `Mul<i64>` `&f64` implements `Mul`
and 57 others and 57 others
error[E0277]: cannot divide `{integer}` by `&str` error[E0277]: cannot divide `{integer}` by `&str`
@ -55,14 +55,14 @@ LL | 4 / "";
| |
= help: the trait `Div<&str>` is not implemented for `{integer}` = help: the trait `Div<&str>` is not implemented for `{integer}`
= help: the following other types implement trait `Div<Rhs>`: = help: the following other types implement trait `Div<Rhs>`:
`&'a f128` implements `Div<f128>` `&f128` implements `Div<f128>`
`&'a f16` implements `Div<f16>` `&f128` implements `Div`
`&'a f32` implements `Div<f32>` `&f16` implements `Div<f16>`
`&'a f64` implements `Div<f64>` `&f16` implements `Div`
`&'a i128` implements `Div<i128>` `&f32` implements `Div<f32>`
`&'a i16` implements `Div<i16>` `&f32` implements `Div`
`&'a i32` implements `Div<i32>` `&f64` implements `Div<f64>`
`&'a i64` implements `Div<i64>` `&f64` implements `Div`
and 62 others and 62 others
error[E0277]: can't compare `{integer}` with `String` error[E0277]: can't compare `{integer}` with `String`

4
tests/ui/never_type/issue-13352.stderr
View File

@ -6,8 +6,8 @@ LL | 2_usize + (loop {});
| |
= help: the trait `Add<()>` is not implemented for `usize` = help: the trait `Add<()>` is not implemented for `usize`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a usize` implements `Add<usize>` `&usize` implements `Add<usize>`
`&usize` implements `Add<&usize>` `&usize` implements `Add`
`usize` implements `Add<&usize>` `usize` implements `Add<&usize>`
`usize` implements `Add` `usize` implements `Add`

48
tests/ui/numbers-arithmetic/not-suggest-float-literal.stderr
View File

@ -6,8 +6,8 @@ LL | x + 100.0
| |
= help: the trait `Add<{float}>` is not implemented for `u8` = help: the trait `Add<{float}>` is not implemented for `u8`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a u8` implements `Add<u8>` `&u8` implements `Add<u8>`
`&u8` implements `Add<&u8>` `&u8` implements `Add`
`u8` implements `Add<&u8>` `u8` implements `Add<&u8>`
`u8` implements `Add` `u8` implements `Add`
@ -19,8 +19,8 @@ LL | x + "foo"
| |
= help: the trait `Add<&str>` is not implemented for `f64` = help: the trait `Add<&str>` is not implemented for `f64`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a f64` implements `Add<f64>` `&f64` implements `Add<f64>`
`&f64` implements `Add<&f64>` `&f64` implements `Add`
`f64` implements `Add<&f64>` `f64` implements `Add<&f64>`
`f64` implements `Add` `f64` implements `Add`
@ -32,8 +32,8 @@ LL | x + y
| |
= help: the trait `Add<{integer}>` is not implemented for `f64` = help: the trait `Add<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a f64` implements `Add<f64>` `&f64` implements `Add<f64>`
`&f64` implements `Add<&f64>` `&f64` implements `Add`
`f64` implements `Add<&f64>` `f64` implements `Add<&f64>`
`f64` implements `Add` `f64` implements `Add`
@ -45,8 +45,8 @@ LL | x - 100.0
| |
= help: the trait `Sub<{float}>` is not implemented for `u8` = help: the trait `Sub<{float}>` is not implemented for `u8`
= help: the following other types implement trait `Sub<Rhs>`: = help: the following other types implement trait `Sub<Rhs>`:
`&'a u8` implements `Sub<u8>` `&u8` implements `Sub<u8>`
`&u8` implements `Sub<&u8>` `&u8` implements `Sub`
`u8` implements `Sub<&u8>` `u8` implements `Sub<&u8>`
`u8` implements `Sub` `u8` implements `Sub`
@ -58,8 +58,8 @@ LL | x - "foo"
| |
= help: the trait `Sub<&str>` is not implemented for `f64` = help: the trait `Sub<&str>` is not implemented for `f64`
= help: the following other types implement trait `Sub<Rhs>`: = help: the following other types implement trait `Sub<Rhs>`:
`&'a f64` implements `Sub<f64>` `&f64` implements `Sub<f64>`
`&f64` implements `Sub<&f64>` `&f64` implements `Sub`
`f64` implements `Sub<&f64>` `f64` implements `Sub<&f64>`
`f64` implements `Sub` `f64` implements `Sub`
@ -71,8 +71,8 @@ LL | x - y
| |
= help: the trait `Sub<{integer}>` is not implemented for `f64` = help: the trait `Sub<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Sub<Rhs>`: = help: the following other types implement trait `Sub<Rhs>`:
`&'a f64` implements `Sub<f64>` `&f64` implements `Sub<f64>`
`&f64` implements `Sub<&f64>` `&f64` implements `Sub`
`f64` implements `Sub<&f64>` `f64` implements `Sub<&f64>`
`f64` implements `Sub` `f64` implements `Sub`
@ -84,8 +84,8 @@ LL | x * 100.0
| |
= help: the trait `Mul<{float}>` is not implemented for `u8` = help: the trait `Mul<{float}>` is not implemented for `u8`
= help: the following other types implement trait `Mul<Rhs>`: = help: the following other types implement trait `Mul<Rhs>`:
`&'a u8` implements `Mul<u8>` `&u8` implements `Mul<u8>`
`&u8` implements `Mul<&u8>` `&u8` implements `Mul`
`u8` implements `Mul<&u8>` `u8` implements `Mul<&u8>`
`u8` implements `Mul` `u8` implements `Mul`
@ -97,8 +97,8 @@ LL | x * "foo"
| |
= help: the trait `Mul<&str>` is not implemented for `f64` = help: the trait `Mul<&str>` is not implemented for `f64`
= help: the following other types implement trait `Mul<Rhs>`: = help: the following other types implement trait `Mul<Rhs>`:
`&'a f64` implements `Mul<f64>` `&f64` implements `Mul<f64>`
`&f64` implements `Mul<&f64>` `&f64` implements `Mul`
`f64` implements `Mul<&f64>` `f64` implements `Mul<&f64>`
`f64` implements `Mul` `f64` implements `Mul`
@ -110,8 +110,8 @@ LL | x * y
| |
= help: the trait `Mul<{integer}>` is not implemented for `f64` = help: the trait `Mul<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Mul<Rhs>`: = help: the following other types implement trait `Mul<Rhs>`:
`&'a f64` implements `Mul<f64>` `&f64` implements `Mul<f64>`
`&f64` implements `Mul<&f64>` `&f64` implements `Mul`
`f64` implements `Mul<&f64>` `f64` implements `Mul<&f64>`
`f64` implements `Mul` `f64` implements `Mul`
@ -123,8 +123,8 @@ LL | x / 100.0
| |
= help: the trait `Div<{float}>` is not implemented for `u8` = help: the trait `Div<{float}>` is not implemented for `u8`
= help: the following other types implement trait `Div<Rhs>`: = help: the following other types implement trait `Div<Rhs>`:
`&'a u8` implements `Div<u8>` `&u8` implements `Div<u8>`
`&u8` implements `Div<&u8>` `&u8` implements `Div`
`u8` implements `Div<&u8>` `u8` implements `Div<&u8>`
`u8` implements `Div<NonZero<u8>>` `u8` implements `Div<NonZero<u8>>`
`u8` implements `Div` `u8` implements `Div`
@ -137,8 +137,8 @@ LL | x / "foo"
| |
= help: the trait `Div<&str>` is not implemented for `f64` = help: the trait `Div<&str>` is not implemented for `f64`
= help: the following other types implement trait `Div<Rhs>`: = help: the following other types implement trait `Div<Rhs>`:
`&'a f64` implements `Div<f64>` `&f64` implements `Div<f64>`
`&f64` implements `Div<&f64>` `&f64` implements `Div`
`f64` implements `Div<&f64>` `f64` implements `Div<&f64>`
`f64` implements `Div` `f64` implements `Div`
@ -150,8 +150,8 @@ LL | x / y
| |
= help: the trait `Div<{integer}>` is not implemented for `f64` = help: the trait `Div<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Div<Rhs>`: = help: the following other types implement trait `Div<Rhs>`:
`&'a f64` implements `Div<f64>` `&f64` implements `Div<f64>`
`&f64` implements `Div<&f64>` `&f64` implements `Div`
`f64` implements `Div<&f64>` `f64` implements `Div<&f64>`
`f64` implements `Div` `f64` implements `Div`

32
tests/ui/numbers-arithmetic/suggest-float-literal.stderr
View File

@ -6,8 +6,8 @@ LL | x + 100
| |
= help: the trait `Add<{integer}>` is not implemented for `f32` = help: the trait `Add<{integer}>` is not implemented for `f32`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a f32` implements `Add<f32>` `&f32` implements `Add<f32>`
`&f32` implements `Add<&f32>` `&f32` implements `Add`
`f32` implements `Add<&f32>` `f32` implements `Add<&f32>`
`f32` implements `Add` `f32` implements `Add`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
@ -23,8 +23,8 @@ LL | x + 100
| |
= help: the trait `Add<{integer}>` is not implemented for `f64` = help: the trait `Add<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a f64` implements `Add<f64>` `&f64` implements `Add<f64>`
`&f64` implements `Add<&f64>` `&f64` implements `Add`
`f64` implements `Add<&f64>` `f64` implements `Add<&f64>`
`f64` implements `Add` `f64` implements `Add`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
@ -40,8 +40,8 @@ LL | x - 100
| |
= help: the trait `Sub<{integer}>` is not implemented for `f32` = help: the trait `Sub<{integer}>` is not implemented for `f32`
= help: the following other types implement trait `Sub<Rhs>`: = help: the following other types implement trait `Sub<Rhs>`:
`&'a f32` implements `Sub<f32>` `&f32` implements `Sub<f32>`
`&f32` implements `Sub<&f32>` `&f32` implements `Sub`
`f32` implements `Sub<&f32>` `f32` implements `Sub<&f32>`
`f32` implements `Sub` `f32` implements `Sub`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
@ -57,8 +57,8 @@ LL | x - 100
| |
= help: the trait `Sub<{integer}>` is not implemented for `f64` = help: the trait `Sub<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Sub<Rhs>`: = help: the following other types implement trait `Sub<Rhs>`:
`&'a f64` implements `Sub<f64>` `&f64` implements `Sub<f64>`
`&f64` implements `Sub<&f64>` `&f64` implements `Sub`
`f64` implements `Sub<&f64>` `f64` implements `Sub<&f64>`
`f64` implements `Sub` `f64` implements `Sub`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
@ -74,8 +74,8 @@ LL | x * 100
| |
= help: the trait `Mul<{integer}>` is not implemented for `f32` = help: the trait `Mul<{integer}>` is not implemented for `f32`
= help: the following other types implement trait `Mul<Rhs>`: = help: the following other types implement trait `Mul<Rhs>`:
`&'a f32` implements `Mul<f32>` `&f32` implements `Mul<f32>`
`&f32` implements `Mul<&f32>` `&f32` implements `Mul`
`f32` implements `Mul<&f32>` `f32` implements `Mul<&f32>`
`f32` implements `Mul` `f32` implements `Mul`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
@ -91,8 +91,8 @@ LL | x * 100
| |
= help: the trait `Mul<{integer}>` is not implemented for `f64` = help: the trait `Mul<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Mul<Rhs>`: = help: the following other types implement trait `Mul<Rhs>`:
`&'a f64` implements `Mul<f64>` `&f64` implements `Mul<f64>`
`&f64` implements `Mul<&f64>` `&f64` implements `Mul`
`f64` implements `Mul<&f64>` `f64` implements `Mul<&f64>`
`f64` implements `Mul` `f64` implements `Mul`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
@ -108,8 +108,8 @@ LL | x / 100
| |
= help: the trait `Div<{integer}>` is not implemented for `f32` = help: the trait `Div<{integer}>` is not implemented for `f32`
= help: the following other types implement trait `Div<Rhs>`: = help: the following other types implement trait `Div<Rhs>`:
`&'a f32` implements `Div<f32>` `&f32` implements `Div<f32>`
`&f32` implements `Div<&f32>` `&f32` implements `Div`
`f32` implements `Div<&f32>` `f32` implements `Div<&f32>`
`f32` implements `Div` `f32` implements `Div`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
@ -125,8 +125,8 @@ LL | x / 100
| |
= help: the trait `Div<{integer}>` is not implemented for `f64` = help: the trait `Div<{integer}>` is not implemented for `f64`
= help: the following other types implement trait `Div<Rhs>`: = help: the following other types implement trait `Div<Rhs>`:
`&'a f64` implements `Div<f64>` `&f64` implements `Div<f64>`
`&f64` implements `Div<&f64>` `&f64` implements `Div`
`f64` implements `Div<&f64>` `f64` implements `Div<&f64>`
`f64` implements `Div` `f64` implements `Div`
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`

4
tests/ui/on-unimplemented/sum.stderr
View File

@ -8,7 +8,7 @@ LL | vec![(), ()].iter().sum::<i32>();
| |
= help: the trait `Sum<&()>` is not implemented for `i32` = help: the trait `Sum<&()>` is not implemented for `i32`
= help: the following other types implement trait `Sum<A>`: = help: the following other types implement trait `Sum<A>`:
`i32` implements `Sum<&'a i32>` `i32` implements `Sum<&i32>`
`i32` implements `Sum` `i32` implements `Sum`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/sum.rs:4:18 --> $DIR/sum.rs:4:18
@ -30,7 +30,7 @@ LL | vec![(), ()].iter().product::<i32>();
| |
= help: the trait `Product<&()>` is not implemented for `i32` = help: the trait `Product<&()>` is not implemented for `i32`
= help: the following other types implement trait `Product<A>`: = help: the following other types implement trait `Product<A>`:
`i32` implements `Product<&'a i32>` `i32` implements `Product<&i32>`
`i32` implements `Product` `i32` implements `Product`
note: the method call chain might not have had the expected associated types note: the method call chain might not have had the expected associated types
--> $DIR/sum.rs:7:18 --> $DIR/sum.rs:7:18

4
tests/ui/span/multiline-span-simple.stderr
View File

@ -6,8 +6,8 @@ LL | foo(1 as u32 +
| |
= help: the trait `Add<()>` is not implemented for `u32` = help: the trait `Add<()>` is not implemented for `u32`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a u32` implements `Add<u32>` `&u32` implements `Add<u32>`
`&u32` implements `Add<&u32>` `&u32` implements `Add`
`u32` implements `Add<&u32>` `u32` implements `Add<&u32>`
`u32` implements `Add` `u32` implements `Add`

2
tests/ui/suggestions/imm-ref-trait-object-literal-bound-regions.stderr
View File

@ -6,7 +6,7 @@ LL | foo::<S>(s);
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the trait `Trait` is implemented for `&'a mut S` = help: the trait `Trait` is implemented for `&mut S`
= note: `for<'b> Trait` is implemented for `&'b mut S`, but not for `&'b S` = note: `for<'b> Trait` is implemented for `&'b mut S`, but not for `&'b S`
note: required by a bound in `foo` note: required by a bound in `foo`
--> $DIR/imm-ref-trait-object-literal-bound-regions.rs:11:20 --> $DIR/imm-ref-trait-object-literal-bound-regions.rs:11:20

2
tests/ui/suggestions/imm-ref-trait-object-literal.stderr
View File

@ -6,7 +6,7 @@ LL | foo(&s);
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the trait `Trait` is implemented for `&'a mut S` = help: the trait `Trait` is implemented for `&mut S`
note: required by a bound in `foo` note: required by a bound in `foo`
--> $DIR/imm-ref-trait-object-literal.rs:7:11 --> $DIR/imm-ref-trait-object-literal.rs:7:11
| |

2
tests/ui/suggestions/into-str.stderr
View File

@ -12,7 +12,7 @@ LL | foo(String::new());
`String` implements `From<&mut str>` `String` implements `From<&mut str>`
`String` implements `From<&str>` `String` implements `From<&str>`
`String` implements `From<Box<str>>` `String` implements `From<Box<str>>`
`String` implements `From<Cow<'a, str>>` `String` implements `From<Cow<'_, str>>`
`String` implements `From<char>` `String` implements `From<char>`
= note: required for `String` to implement `Into<&str>` = note: required for `String` to implement `Into<&str>`
note: required by a bound in `foo` note: required by a bound in `foo`

2
tests/ui/traits/question-mark-result-err-mismatch.stderr
View File

@ -35,7 +35,7 @@ LL | .map_err(|_| ())?;
`String` implements `From<&mut str>` `String` implements `From<&mut str>`
`String` implements `From<&str>` `String` implements `From<&str>`
`String` implements `From<Box<str>>` `String` implements `From<Box<str>>`
`String` implements `From<Cow<'a, str>>` `String` implements `From<Cow<'_, str>>`
`String` implements `From<char>` `String` implements `From<char>`
= note: required for `Result<(), String>` to implement `FromResidual<Result<Infallible, ()>>` = note: required for `Result<(), String>` to implement `FromResidual<Result<Infallible, ()>>`

4
tests/ui/traits/suggest-dereferences/invalid-suggest-deref-issue-127590.stderr
View File

@ -23,7 +23,7 @@ LL | for (src, dest) in std::iter::zip(fields.iter(), &variant.iter()) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&std::slice::Iter<'_, {integer}>` is not an iterator | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&std::slice::Iter<'_, {integer}>` is not an iterator
| |
= help: the trait `Iterator` is not implemented for `&std::slice::Iter<'_, {integer}>`, which is required by `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>: IntoIterator` = help: the trait `Iterator` is not implemented for `&std::slice::Iter<'_, {integer}>`, which is required by `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>: IntoIterator`
= help: the trait `Iterator` is implemented for `std::slice::Iter<'a, T>` = help: the trait `Iterator` is implemented for `std::slice::Iter<'_, T>`
= note: required for `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>` to implement `Iterator` = note: required for `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>` to implement `Iterator`
= note: required for `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>` to implement `IntoIterator` = note: required for `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>` to implement `IntoIterator`
@ -52,7 +52,7 @@ LL | for (src, dest) in std::iter::zip(fields.iter(), &variant.iter().clone(
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&std::slice::Iter<'_, {integer}>` is not an iterator | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&std::slice::Iter<'_, {integer}>` is not an iterator
| |
= help: the trait `Iterator` is not implemented for `&std::slice::Iter<'_, {integer}>`, which is required by `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>: IntoIterator` = help: the trait `Iterator` is not implemented for `&std::slice::Iter<'_, {integer}>`, which is required by `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>: IntoIterator`
= help: the trait `Iterator` is implemented for `std::slice::Iter<'a, T>` = help: the trait `Iterator` is implemented for `std::slice::Iter<'_, T>`
= note: required for `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>` to implement `Iterator` = note: required for `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>` to implement `Iterator`
= note: required for `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>` to implement `IntoIterator` = note: required for `Zip<std::slice::Iter<'_, {integer}>, &std::slice::Iter<'_, {integer}>>` to implement `IntoIterator`

4
tests/ui/type/type-check-defaults.stderr
View File

@ -66,8 +66,8 @@ LL | trait ProjectionPred<T:Iterator = IntoIter<i32>> where T::Item : Add<u8> {}
| |
= help: the trait `Add<u8>` is not implemented for `i32` = help: the trait `Add<u8>` is not implemented for `i32`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a i32` implements `Add<i32>` `&i32` implements `Add<i32>`
`&i32` implements `Add<&i32>` `&i32` implements `Add`
`i32` implements `Add<&i32>` `i32` implements `Add<&i32>`
`i32` implements `Add` `i32` implements `Add`

4
tests/ui/typeck/issue-81293.stderr
View File

@ -21,8 +21,8 @@ LL | a = c + b * 5;
| |
= help: the trait `Add<u16>` is not implemented for `usize` = help: the trait `Add<u16>` is not implemented for `usize`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a usize` implements `Add<usize>` `&usize` implements `Add<usize>`
`&usize` implements `Add<&usize>` `&usize` implements `Add`
`usize` implements `Add<&usize>` `usize` implements `Add<&usize>`
`usize` implements `Add` `usize` implements `Add`

2
tests/ui/typeck/issue-90101.stderr
View File

@ -9,7 +9,7 @@ LL | func(Path::new("hello").to_path_buf().to_string_lossy(), "world")
= help: the following other types implement trait `From<T>`: = help: the following other types implement trait `From<T>`:
`PathBuf` implements `From<&T>` `PathBuf` implements `From<&T>`
`PathBuf` implements `From<Box<Path>>` `PathBuf` implements `From<Box<Path>>`
`PathBuf` implements `From<Cow<'a, Path>>` `PathBuf` implements `From<Cow<'_, Path>>`
`PathBuf` implements `From<OsString>` `PathBuf` implements `From<OsString>`
`PathBuf` implements `From<String>` `PathBuf` implements `From<String>`
= note: required for `Cow<'_, str>` to implement `Into<PathBuf>` = note: required for `Cow<'_, str>` to implement `Into<PathBuf>`

8
tests/ui/ufcs/ufcs-qpath-self-mismatch.stderr
View File

@ -6,8 +6,8 @@ LL | <i32 as Add<u32>>::add(1, 2);
| |
= help: the trait `Add<u32>` is not implemented for `i32` = help: the trait `Add<u32>` is not implemented for `i32`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a i32` implements `Add<i32>` `&i32` implements `Add<i32>`
`&i32` implements `Add<&i32>` `&i32` implements `Add`
`i32` implements `Add<&i32>` `i32` implements `Add<&i32>`
`i32` implements `Add` `i32` implements `Add`
@ -63,8 +63,8 @@ LL | <i32 as Add<u32>>::add(1, 2);
| |
= help: the trait `Add<u32>` is not implemented for `i32` = help: the trait `Add<u32>` is not implemented for `i32`
= help: the following other types implement trait `Add<Rhs>`: = help: the following other types implement trait `Add<Rhs>`:
`&'a i32` implements `Add<i32>` `&i32` implements `Add<i32>`
`&i32` implements `Add<&i32>` `&i32` implements `Add`
`i32` implements `Add<&i32>` `i32` implements `Add<&i32>`
`i32` implements `Add` `i32` implements `Add`