bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Dedup logic and improve output for other types that impl trait

Browse source
This commit is contained in:
Esteban Kuber 2022-03-27 01:49:01 +00:00
parent e2bba0708a
commit ef91519b45
47 changed files with 363 additions and 357 deletions
Download patch file Download diff file Expand all files Collapse all files

121
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View file

@ -30,7 +30,7 @@ use rustc_middle::traits::select::OverflowError;
use rustc_middle::ty::error::ExpectedFound; use rustc_middle::ty::error::ExpectedFound;
use rustc_middle::ty::fold::TypeFolder; use rustc_middle::ty::fold::TypeFolder;
use rustc_middle::ty::{ use rustc_middle::ty::{
self, SubtypePredicate, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, TypeFoldable, self, SubtypePredicate, ToPolyTraitRef, ToPredicate, TraitRef, Ty, TyCtxt, TypeFoldable,
}; };
use rustc_span::symbol::{kw, sym}; use rustc_span::symbol::{kw, sym};
use rustc_span::{ExpnKind, MultiSpan, Span, DUMMY_SP}; use rustc_span::{ExpnKind, MultiSpan, Span, DUMMY_SP};
@ -1756,6 +1756,60 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
trait_ref: ty::PolyTraitRef<'tcx>, trait_ref: ty::PolyTraitRef<'tcx>,
err: &mut Diagnostic, err: &mut Diagnostic,
) -> bool { ) -> bool {
let report = |mut candidates: Vec<TraitRef<'_>>, err: &mut Diagnostic| {
candidates.sort();
candidates.dedup();
let len = candidates.len();
if candidates.len() == 0 {
return false;
}
let trait_ref = candidates[0];
if candidates.len() == 1 {
err.highlighted_help(vec![
(
format!(
"the trait `{}` is implemented for `",
trait_ref.print_only_trait_path()
),
Style::NoStyle,
),
(candidates[0].self_ty().to_string(), Style::Highlight),
("`".to_string(), Style::NoStyle),
]);
return true;
}
// Check if the trait is the same in all cases. If so, we'll only show the type.
// FIXME: there *has* to be a better way!
let mut traits: Vec<_> = candidates
.iter()
.map(|c| format!("{}", c).split(" as ").last().unwrap().to_string())
.collect();
traits.sort();
traits.dedup();
let mut candidates: Vec<String> = candidates
.into_iter()
.map(|c| {
if traits.len() == 1 {
format!("\n {}", c.self_ty())
} else {
format!("\n {}", c)
}
})
.collect();
candidates.sort();
candidates.dedup();
let end = if candidates.len() <= 9 { candidates.len() } else { 8 };
err.help(&format!(
"the following other types implement trait `{}`:{}{}",
trait_ref.print_only_trait_path(),
candidates[..end].join(""),
if len > 9 { format!("\nand {} others", len - 8) } else { String::new() }
));
true
};
let def_id = trait_ref.def_id(); let def_id = trait_ref.def_id();
if impl_candidates.is_empty() { if impl_candidates.is_empty() {
if self.tcx.trait_is_auto(def_id) if self.tcx.trait_is_auto(def_id)
@ -1765,7 +1819,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
// Mentioning implementers of `Copy`, `Debug` and friends is not useful. // Mentioning implementers of `Copy`, `Debug` and friends is not useful.
return false; return false;
} }
let mut normalized_impl_candidates: Vec<_> = self let normalized_impl_candidates: Vec<_> = self
.tcx .tcx
.all_impls(def_id) .all_impls(def_id)
// Ignore automatically derived impls and `!Trait` impls. // Ignore automatically derived impls and `!Trait` impls.
@ -1776,45 +1830,10 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
.filter_map(|def_id| self.tcx.impl_trait_ref(def_id)) .filter_map(|def_id| self.tcx.impl_trait_ref(def_id))
// Avoid mentioning type parameters. // Avoid mentioning type parameters.
.filter(|trait_ref| !matches!(trait_ref.self_ty().kind(), ty::Param(_))) .filter(|trait_ref| !matches!(trait_ref.self_ty().kind(), ty::Param(_)))
.map(|trait_ref| format!("\n {}", trait_ref.self_ty()))
.collect(); .collect();
normalized_impl_candidates.sort(); return report(normalized_impl_candidates, err);
normalized_impl_candidates.dedup();
let len = normalized_impl_candidates.len();
if len == 0 {
return false;
}
if len == 1 {
err.highlighted_help(vec![
(
format!(
"the trait `{}` is implemented for `",
trait_ref.print_only_trait_path()
),
Style::NoStyle,
),
(normalized_impl_candidates[0].trim().to_string(), Style::Highlight),
("`".to_string(), Style::NoStyle),
]);
return true;
}
let end = if normalized_impl_candidates.len() <= 9 {
normalized_impl_candidates.len()
} else {
8
};
err.help(&format!(
"the following other types implement trait `{}`:{}{}",
trait_ref.print_only_trait_path(),
normalized_impl_candidates[..end].join(""),
if len > 9 { format!("\nand {} others", len - 8) } else { String::new() }
));
return true;
} }
let len = impl_candidates.len();
let end = if impl_candidates.len() <= 9 { impl_candidates.len() } else { 8 };
let normalize = |candidate| { let normalize = |candidate| {
self.tcx.infer_ctxt().enter(|ref infcx| { self.tcx.infer_ctxt().enter(|ref infcx| {
let normalized = infcx let normalized = infcx
@ -1822,8 +1841,8 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
.normalize(candidate) .normalize(candidate)
.ok(); .ok();
match normalized { match normalized {
Some(normalized) => format!("\n {}", normalized.value), Some(normalized) => normalized.value,
None => format!("\n {}", candidate), None => candidate,
} }
}) })
}; };
@ -1834,7 +1853,6 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
// //
// Prefer more similar candidates first, then sort lexicographically // Prefer more similar candidates first, then sort lexicographically
// by their normalized string representation. // by their normalized string representation.
let first_candidate = impl_candidates.get(0).map(|candidate| candidate.trait_ref);
let mut normalized_impl_candidates_and_similarities = impl_candidates let mut normalized_impl_candidates_and_similarities = impl_candidates
.into_iter() .into_iter()
.map(|ImplCandidate { trait_ref, similarity }| { .map(|ImplCandidate { trait_ref, similarity }| {
@ -1850,26 +1868,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
.map(|(_, normalized)| normalized) .map(|(_, normalized)| normalized)
.collect::<Vec<_>>(); .collect::<Vec<_>>();
if normalized_impl_candidates.len() == 1 { report(normalized_impl_candidates, err)
err.highlighted_help(vec![
(
format!(
"the trait `{}` is implemented for `",
first_candidate.unwrap().print_only_trait_path()
),
Style::NoStyle,
),
(first_candidate.unwrap().self_ty().to_string(), Style::Highlight),
("`".to_string(), Style::NoStyle),
]);
} else {
err.help(&format!(
"the following implementations were found:{}{}",
normalized_impl_candidates[..end].join(""),
if len > 9 { format!("\nand {} others", len - 8) } else { String::new() }
));
}
true
} }
/// Gets the parent trait chain start /// Gets the parent trait chain start

7
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View file

@ -557,8 +557,11 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
} }
} else if real_trait_pred != trait_pred { } else if real_trait_pred != trait_pred {
// This branch addresses #87437. // This branch addresses #87437.
let obligation = let obligation = self.mk_trait_obligation_with_new_self_ty(
self.mk_trait_obligation_with_new_self_ty(param_env, real_trait_pred, base_ty); param_env,
real_trait_pred,
base_ty,
);
if self.predicate_may_hold(&obligation) { if self.predicate_may_hold(&obligation) {
err.span_suggestion_verbose( err.span_suggestion_verbose(
span.shrink_to_lo(), span.shrink_to_lo(),

10
src/test/ui/binop/binop-mul-i32-f32.stderr
View file

@ -5,15 +5,15 @@ LL | x * y
| ^ no implementation for `i32 * f32` | ^ no implementation for `i32 * f32`
| |
= help: the trait `Mul<f32>` is not implemented for `i32` = help: the trait `Mul<f32>` is not implemented for `i32`
= help: the following implementations were found: = help: the following other types implement trait `Mul`:
<&'a i32 as Mul<i32>>
<&i32 as Mul<&i32>>
<i32 as Mul<&i32>>
<i32 as Mul>
<&'a f32 as Mul<f32>> <&'a f32 as Mul<f32>>
<&'a f64 as Mul<f64>> <&'a f64 as Mul<f64>>
<&'a i128 as Mul<i128>> <&'a i128 as Mul<i128>>
<&'a i16 as Mul<i16>> <&'a i16 as Mul<i16>>
<&'a i32 as Mul<i32>>
<&'a i64 as Mul<i64>>
<&'a i8 as Mul<i8>>
<&'a isize as Mul<isize>>
and 49 others and 49 others
error: aborting due to previous error error: aborting due to previous error

18
src/test/ui/binop/issue-77910-1.stderr
View file

@ -16,15 +16,15 @@ LL | assert_eq!(foo, y);
| ^^^^^^^^^^^^^^^^^^ `for<'r> fn(&'r i32) -> &'r i32 {foo}` cannot be formatted using `{:?}` because it doesn't implement `Debug` | ^^^^^^^^^^^^^^^^^^ `for<'r> fn(&'r i32) -> &'r i32 {foo}` cannot be formatted using `{:?}` because it doesn't implement `Debug`
| |
= help: the trait `Debug` is not implemented for `for<'r> fn(&'r i32) -> &'r i32 {foo}` = help: the trait `Debug` is not implemented for `for<'r> fn(&'r i32) -> &'r i32 {foo}`
= help: the following implementations were found: = help: the following other types implement trait `Debug`:
<extern "C" fn() -> Ret as Debug> extern "C" fn() -> Ret
<extern "C" fn(A) -> Ret as Debug> extern "C" fn(A) -> Ret
<extern "C" fn(A, ...) -> Ret as Debug> extern "C" fn(A, ...) -> Ret
<extern "C" fn(A, B) -> Ret as Debug> extern "C" fn(A, B) -> Ret
<extern "C" fn(A, B, ...) -> Ret as Debug> extern "C" fn(A, B, ...) -> Ret
<extern "C" fn(A, B, C) -> Ret as Debug> extern "C" fn(A, B, C) -> Ret
<extern "C" fn(A, B, C, ...) -> Ret as Debug> extern "C" fn(A, B, C, ...) -> Ret
<extern "C" fn(A, B, C, D) -> Ret as Debug> extern "C" fn(A, B, C, D) -> Ret
and 68 others and 68 others
= note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info) = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)

6
src/test/ui/binop/shift-various-bad-types.stderr
View file

@ -5,7 +5,7 @@ LL | 22 >> p.char;
| ^^ no implementation for `{integer} >> char` | ^^ no implementation for `{integer} >> char`
| |
= help: the trait `Shr<char>` is not implemented for `{integer}` = help: the trait `Shr<char>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `Shr`:
<&'a i128 as Shr<i128>> <&'a i128 as Shr<i128>>
<&'a i128 as Shr<i16>> <&'a i128 as Shr<i16>>
<&'a i128 as Shr<i32>> <&'a i128 as Shr<i32>>
@ -23,7 +23,7 @@ LL | 22 >> p.str;
| ^^ no implementation for `{integer} >> &str` | ^^ no implementation for `{integer} >> &str`
| |
= help: the trait `Shr<&str>` is not implemented for `{integer}` = help: the trait `Shr<&str>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `Shr`:
<&'a i128 as Shr<i128>> <&'a i128 as Shr<i128>>
<&'a i128 as Shr<i16>> <&'a i128 as Shr<i16>>
<&'a i128 as Shr<i32>> <&'a i128 as Shr<i32>>
@ -41,7 +41,7 @@ LL | 22 >> p;
| ^^ no implementation for `{integer} >> &Panolpy` | ^^ no implementation for `{integer} >> &Panolpy`
| |
= help: the trait `Shr<&Panolpy>` is not implemented for `{integer}` = help: the trait `Shr<&Panolpy>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `Shr`:
<&'a i128 as Shr<i128>> <&'a i128 as Shr<i128>>
<&'a i128 as Shr<i16>> <&'a i128 as Shr<i16>>
<&'a i128 as Shr<i32>> <&'a i128 as Shr<i32>>

6
src/test/ui/chalkify/chalk_initial_program.stderr
View file

@ -4,9 +4,9 @@ error[E0277]: the trait bound `f32: Foo` is not satisfied
LL | gimme::<f32>(); LL | gimme::<f32>();
| ^^^ the trait `Foo` is not implemented for `f32` | ^^^ the trait `Foo` is not implemented for `f32`
| |
= help: the following implementations were found: = help: the following other types implement trait `Foo`:
<i32 as Foo> i32
<u32 as Foo> u32
note: required by a bound in `gimme` note: required by a bound in `gimme`
--> $DIR/chalk_initial_program.rs:9:13 --> $DIR/chalk_initial_program.rs:9:13
| |

6
src/test/ui/chalkify/type_inference.stderr
View file

@ -6,9 +6,9 @@ LL | only_bar(x);
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the following implementations were found: = help: the following other types implement trait `Bar`:
<i32 as Bar> i32
<u32 as Bar> u32
note: required by a bound in `only_bar` note: required by a bound in `only_bar`
--> $DIR/type_inference.rs:12:16 --> $DIR/type_inference.rs:12:16
| |

6
src/test/ui/const-generics/defaults/rp_impl_trait_fail.stderr
View file

@ -25,7 +25,7 @@ error[E0277]: the trait bound `u32: Traitor<N, N>` is not satisfied
LL | fn uwu<const N: u8>() -> impl Traitor<N> { LL | fn uwu<const N: u8>() -> impl Traitor<N> {
| ^^^^^^^^^^^^^^^ the trait `Traitor<N, N>` is not implemented for `u32` | ^^^^^^^^^^^^^^^ the trait `Traitor<N, N>` is not implemented for `u32`
| |
= help: the following implementations were found: = help: the following other types implement trait `Traitor<N, 2_u8>`:
<u32 as Traitor<N, 2_u8>> <u32 as Traitor<N, 2_u8>>
<u64 as Traitor<1_u8, 2_u8>> <u64 as Traitor<1_u8, 2_u8>>
@ -50,9 +50,9 @@ error[E0277]: the trait bound `u64: Traitor<1_u8, 1_u8>` is not satisfied
LL | fn owo() -> impl Traitor { LL | fn owo() -> impl Traitor {
| ^^^^^^^^^^^^ the trait `Traitor<1_u8, 1_u8>` is not implemented for `u64` | ^^^^^^^^^^^^ the trait `Traitor<1_u8, 1_u8>` is not implemented for `u64`
| |
= help: the following implementations were found: = help: the following other types implement trait `Traitor<N, 2_u8>`:
<u64 as Traitor<1_u8, 2_u8>>
<u32 as Traitor<N, 2_u8>> <u32 as Traitor<N, 2_u8>>
<u64 as Traitor<1_u8, 2_u8>>
error[E0277]: the trait bound `u64: Traitor<1_u8, 1_u8>` is not satisfied error[E0277]: the trait bound `u64: Traitor<1_u8, 1_u8>` is not satisfied
--> $DIR/rp_impl_trait_fail.rs:24:26 --> $DIR/rp_impl_trait_fail.rs:24:26

2
src/test/ui/const-generics/exhaustive-value.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: the trait bound `(): Foo<N>` is not satisfied
LL | <() as Foo<N>>::test() LL | <() as Foo<N>>::test()
| ^^^^^^^^^^^^^^^^^^^^ the trait `Foo<N>` is not implemented for `()` | ^^^^^^^^^^^^^^^^^^^^ the trait `Foo<N>` is not implemented for `()`
| |
= help: the following implementations were found: = help: the following other types implement trait `Foo<0_u8>`:
<() as Foo<0_u8>> <() as Foo<0_u8>>
<() as Foo<100_u8>> <() as Foo<100_u8>>
<() as Foo<101_u8>> <() as Foo<101_u8>>

36
src/test/ui/const-generics/issues/issue-67185-2.stderr
View file

@ -4,9 +4,9 @@ error[E0277]: the trait bound `[u16; 3]: Bar` is not satisfied
LL | <u8 as Baz>::Quaks: Bar, LL | <u8 as Baz>::Quaks: Bar,
| ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bar` is not implemented for `[u16; 3]` | ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bar` is not implemented for `[u16; 3]`
| |
= help: the following implementations were found: = help: the following other types implement trait `Bar`:
<[[u16; 3]; 3] as Bar> [[u16; 3]; 3]
<[u16; 4] as Bar> [u16; 4]
= help: see issue #48214 = help: see issue #48214
= help: add `#![feature(trivial_bounds)]` to the crate attributes to enable = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@ -16,9 +16,9 @@ error[E0277]: the trait bound `[[u16; 3]; 2]: Bar` is not satisfied
LL | [<u8 as Baz>::Quaks; 2]: Bar, LL | [<u8 as Baz>::Quaks; 2]: Bar,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bar` is not implemented for `[[u16; 3]; 2]` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Bar` is not implemented for `[[u16; 3]; 2]`
| |
= help: the following implementations were found: = help: the following other types implement trait `Bar`:
<[[u16; 3]; 3] as Bar> [[u16; 3]; 3]
<[u16; 4] as Bar> [u16; 4]
= help: see issue #48214 = help: see issue #48214
= help: add `#![feature(trivial_bounds)]` to the crate attributes to enable = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
@ -28,9 +28,9 @@ error[E0277]: the trait bound `[u16; 3]: Bar` is not satisfied
LL | impl Foo for FooImpl {} LL | impl Foo for FooImpl {}
| ^^^ the trait `Bar` is not implemented for `[u16; 3]` | ^^^ the trait `Bar` is not implemented for `[u16; 3]`
| |
= help: the following implementations were found: = help: the following other types implement trait `Bar`:
<[[u16; 3]; 3] as Bar> [[u16; 3]; 3]
<[u16; 4] as Bar> [u16; 4]
note: required by a bound in `Foo` note: required by a bound in `Foo`
--> $DIR/issue-67185-2.rs:15:25 --> $DIR/issue-67185-2.rs:15:25
| |
@ -46,9 +46,9 @@ error[E0277]: the trait bound `[[u16; 3]; 2]: Bar` is not satisfied
LL | impl Foo for FooImpl {} LL | impl Foo for FooImpl {}
| ^^^ the trait `Bar` is not implemented for `[[u16; 3]; 2]` | ^^^ the trait `Bar` is not implemented for `[[u16; 3]; 2]`
| |
= help: the following implementations were found: = help: the following other types implement trait `Bar`:
<[[u16; 3]; 3] as Bar> [[u16; 3]; 3]
<[u16; 4] as Bar> [u16; 4]
note: required by a bound in `Foo` note: required by a bound in `Foo`
--> $DIR/issue-67185-2.rs:14:30 --> $DIR/issue-67185-2.rs:14:30
| |
@ -64,9 +64,9 @@ error[E0277]: the trait bound `[[u16; 3]; 2]: Bar` is not satisfied
LL | fn f(_: impl Foo) {} LL | fn f(_: impl Foo) {}
| ^^^ the trait `Bar` is not implemented for `[[u16; 3]; 2]` | ^^^ the trait `Bar` is not implemented for `[[u16; 3]; 2]`
| |
= help: the following implementations were found: = help: the following other types implement trait `Bar`:
<[[u16; 3]; 3] as Bar> [[u16; 3]; 3]
<[u16; 4] as Bar> [u16; 4]
note: required by a bound in `Foo` note: required by a bound in `Foo`
--> $DIR/issue-67185-2.rs:14:30 --> $DIR/issue-67185-2.rs:14:30
| |
@ -82,9 +82,9 @@ error[E0277]: the trait bound `[u16; 3]: Bar` is not satisfied
LL | fn f(_: impl Foo) {} LL | fn f(_: impl Foo) {}
| ^^^ the trait `Bar` is not implemented for `[u16; 3]` | ^^^ the trait `Bar` is not implemented for `[u16; 3]`
| |
= help: the following implementations were found: = help: the following other types implement trait `Bar`:
<[[u16; 3]; 3] as Bar> [[u16; 3]; 3]
<[u16; 4] as Bar> [u16; 4]
note: required by a bound in `Foo` note: required by a bound in `Foo`
--> $DIR/issue-67185-2.rs:15:25 --> $DIR/issue-67185-2.rs:15:25
| |

2
src/test/ui/const-generics/occurs-check/unused-substs-1.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: the trait bound `A<{_: usize}>: Bar<{_: usize}>` is not satisfied
LL | let _ = A; LL | let _ = A;
| ^ the trait `Bar<{_: usize}>` is not implemented for `A<{_: usize}>` | ^ the trait `Bar<{_: usize}>` is not implemented for `A<{_: usize}>`
| |
= help: the trait `Bar<N>` is implemented for `A<{ 6 + 1 }>` = help: the trait `Bar<N>` is implemented for `A<7_usize>`
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
| |

10
src/test/ui/consts/const-eval/const-eval-overflow-3b.stderr
View file

@ -11,15 +11,15 @@ LL | = [0; (i8::MAX + 1u8) as usize];
| ^ no implementation for `i8 + u8` | ^ no implementation for `i8 + u8`
| |
= help: the trait `Add<u8>` is not implemented for `i8` = help: the trait `Add<u8>` is not implemented for `i8`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a i8 as Add<i8>>
<&i8 as Add<&i8>>
<i8 as Add<&i8>>
<i8 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error: aborting due to 2 previous errors error: aborting due to 2 previous errors

10
src/test/ui/consts/const-eval/const-eval-overflow-4b.stderr
View file

@ -11,15 +11,15 @@ LL | : [u32; (i8::MAX as i8 + 1u8) as usize]
| ^ no implementation for `i8 + u8` | ^ no implementation for `i8 + u8`
| |
= help: the trait `Add<u8>` is not implemented for `i8` = help: the trait `Add<u8>` is not implemented for `i8`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a i8 as Add<i8>>
<&i8 as Add<&i8>>
<i8 as Add<&i8>>
<i8 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error[E0604]: only `u8` can be cast as `char`, not `i8` error[E0604]: only `u8` can be cast as `char`, not `i8`

2
src/test/ui/consts/too_generic_eval_ice.stderr
View file

@ -21,7 +21,7 @@ LL | [5; Self::HOST_SIZE] == [6; 0]
| ^^ no implementation for `[{integer}; _] == [{integer}; 0]` | ^^ no implementation for `[{integer}; _] == [{integer}; 0]`
| |
= help: the trait `PartialEq<[{integer}; 0]>` is not implemented for `[{integer}; _]` = help: the trait `PartialEq<[{integer}; 0]>` is not implemented for `[{integer}; _]`
= help: the following implementations were found: = help: the following other types implement trait `PartialEq<[B; N]>`:
<&[B] as PartialEq<[A; N]>> <&[B] as PartialEq<[A; N]>>
<&[T] as PartialEq<Vec<U, A>>> <&[T] as PartialEq<Vec<U, A>>>
<&mut [B] as PartialEq<[A; N]>> <&mut [B] as PartialEq<[A; N]>>

2
src/test/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: the trait bound `Bar: Foo<usize>` is not satisfied
LL | f1.foo(1usize); LL | f1.foo(1usize);
| ^^^ the trait `Foo<usize>` is not implemented for `Bar` | ^^^ the trait `Foo<usize>` is not implemented for `Bar`
| |
= help: the following implementations were found: = help: the following other types implement trait `Foo<i32>`:
<Bar as Foo<i32>> <Bar as Foo<i32>>
<Bar as Foo<u8>> <Bar as Foo<u8>>

2
src/test/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: the trait bound `Bar: Foo<usize>` is not satisfied
LL | f1.foo(1usize); LL | f1.foo(1usize);
| ^^^ the trait `Foo<usize>` is not implemented for `Bar` | ^^^ the trait `Foo<usize>` is not implemented for `Bar`
| |
= help: the following implementations were found: = help: the following other types implement trait `Foo<i8>`:
<Bar as Foo<i16>> <Bar as Foo<i16>>
<Bar as Foo<i32>> <Bar as Foo<i32>>
<Bar as Foo<i8>> <Bar as Foo<i8>>

14
src/test/ui/did_you_mean/issue-39802-show-5-trait-impls.stderr
View file

@ -6,7 +6,7 @@ LL | Foo::<i32>::bar(&1i8);
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the following implementations were found: = help: the following other types implement trait `Foo<bool>`:
<i8 as Foo<bool>> <i8 as Foo<bool>>
<i8 as Foo<u16>> <i8 as Foo<u16>>
<i8 as Foo<u32>> <i8 as Foo<u32>>
@ -25,16 +25,16 @@ LL | Foo::<i32>::bar(&1u8);
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the following implementations were found: = help: the following other types implement trait `Foo<bool>`:
<u8 as Foo<bool>>
<u8 as Foo<u16>>
<u8 as Foo<u32>>
<u8 as Foo<u64>>
<i8 as Foo<bool>> <i8 as Foo<bool>>
<i8 as Foo<u16>> <i8 as Foo<u16>>
<i8 as Foo<u32>> <i8 as Foo<u32>>
<i8 as Foo<u64>> <i8 as Foo<u64>>
<i8 as Foo<u8>> <i8 as Foo<u8>>
<u8 as Foo<bool>>
<u8 as Foo<u16>>
<u8 as Foo<u32>>
<u8 as Foo<u64>>
error[E0277]: the trait bound `bool: Foo<i32>` is not satisfied error[E0277]: the trait bound `bool: Foo<i32>` is not satisfied
--> $DIR/issue-39802-show-5-trait-impls.rs:26:21 --> $DIR/issue-39802-show-5-trait-impls.rs:26:21
@ -44,7 +44,7 @@ LL | Foo::<i32>::bar(&true);
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the following implementations were found: = help: the following other types implement trait `Foo<bool>`:
<bool as Foo<bool>> <bool as Foo<bool>>
<bool as Foo<i8>> <bool as Foo<i8>>
<bool as Foo<u16>> <bool as Foo<u16>>

2
src/test/ui/did_you_mean/issue-49746-unicode-confusable-in-float-literal-expt.stderr
View file

@ -22,7 +22,7 @@ LL | const UNIVERSAL_GRAVITATIONAL_CONSTANT: f64 = 6.674e−11; // m³⋅kg⁻¹
| ^ no implementation for `{float} - {integer}` | ^ no implementation for `{float} - {integer}`
| |
= help: the trait `Sub<{integer}>` is not implemented for `{float}` = help: the trait `Sub<{integer}>` is not implemented for `{float}`
= help: the following implementations were found: = help: the following other types implement trait `Sub`:
<&'a f32 as Sub<f32>> <&'a f32 as Sub<f32>>
<&'a f64 as Sub<f64>> <&'a f64 as Sub<f64>>
<&'a i128 as Sub<i128>> <&'a i128 as Sub<i128>>

2
src/test/ui/generic-associated-types/bugs/issue-88460.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: the trait bound `for<'a> <_ as Trait>::Assoc<'a>: Marker` is not s
LL | test(Foo); LL | test(Foo);
| ^^^^ the trait `for<'a> Marker` is not implemented for `<_ as Trait>::Assoc<'a>` | ^^^^ the trait `for<'a> Marker` is not implemented for `<_ as Trait>::Assoc<'a>`
| |
= help: the trait `for<'a> Marker` is implemented for `()` = help: the trait `Marker` is implemented for `()`
note: required by a bound in `test` note: required by a bound in `test`
--> $DIR/issue-88460.rs:17:27 --> $DIR/issue-88460.rs:17:27
| |

10
src/test/ui/impl-trait/equality.stderr
View file

@ -24,15 +24,15 @@ LL | n + sum_to(n - 1)
| ^ no implementation for `u32 + impl Foo` | ^ no implementation for `u32 + impl Foo`
| |
= 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 implementations were found: = help: the following other types implement trait `Add`:
<&'a u32 as Add<u32>>
<&u32 as Add<&u32>>
<u32 as Add<&u32>>
<u32 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error: aborting due to 2 previous errors; 1 warning emitted error: aborting due to 2 previous errors; 1 warning emitted

4
src/test/ui/issues/issue-11771.stderr
View file

@ -5,7 +5,7 @@ LL | 1 +
| ^ no implementation for `{integer} + ()` | ^ no implementation for `{integer} + ()`
| |
= help: the trait `Add<()>` is not implemented for `{integer}` = help: the trait `Add<()>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
@ -23,7 +23,7 @@ LL | 1 +
| ^ no implementation for `{integer} + ()` | ^ no implementation for `{integer} + ()`
| |
= help: the trait `Add<()>` is not implemented for `{integer}` = help: the trait `Add<()>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>

10
src/test/ui/issues/issue-24352.stderr
View file

@ -5,15 +5,15 @@ LL | 1.0f64 - 1
| ^ no implementation for `f64 - {integer}` | ^ no implementation for `f64 - {integer}`
| |
= help: the trait `Sub<{integer}>` is not implemented for `f64` = help: the trait `Sub<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Sub`:
<&'a f64 as Sub<f64>>
<&f64 as Sub<&f64>>
<f64 as Sub<&f64>>
<f64 as Sub>
<&'a f32 as Sub<f32>> <&'a f32 as Sub<f32>>
<&'a f64 as Sub<f64>>
<&'a i128 as Sub<i128>> <&'a i128 as Sub<i128>>
<&'a i16 as Sub<i16>> <&'a i16 as Sub<i16>>
<&'a i32 as Sub<i32>> <&'a i32 as Sub<i32>>
<&'a i64 as Sub<i64>>
<&'a i8 as Sub<i8>>
<&'a isize as Sub<isize>>
and 48 others and 48 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |

2
src/test/ui/issues/issue-50582.stderr
View file

@ -14,7 +14,7 @@ LL | Vec::<[(); 1 + for x in 0..1 {}]>::new();
| ^ no implementation for `{integer} + ()` | ^ no implementation for `{integer} + ()`
| |
= help: the trait `Add<()>` is not implemented for `{integer}` = help: the trait `Add<()>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>

18
src/test/ui/issues/issue-59488.stderr
View file

@ -94,15 +94,15 @@ LL | assert_eq!(Foo::Bar, i);
| ^^^^^^^^^^^^^^^^^^^^^^^ `fn(usize) -> Foo {Foo::Bar}` cannot be formatted using `{:?}` because it doesn't implement `Debug` | ^^^^^^^^^^^^^^^^^^^^^^^ `fn(usize) -> Foo {Foo::Bar}` cannot be formatted using `{:?}` because it doesn't implement `Debug`
| |
= help: the trait `Debug` is not implemented for `fn(usize) -> Foo {Foo::Bar}` = help: the trait `Debug` is not implemented for `fn(usize) -> Foo {Foo::Bar}`
= help: the following implementations were found: = help: the following other types implement trait `Debug`:
<extern "C" fn() -> Ret as Debug> extern "C" fn() -> Ret
<extern "C" fn(A) -> Ret as Debug> extern "C" fn(A) -> Ret
<extern "C" fn(A, ...) -> Ret as Debug> extern "C" fn(A, ...) -> Ret
<extern "C" fn(A, B) -> Ret as Debug> extern "C" fn(A, B) -> Ret
<extern "C" fn(A, B, ...) -> Ret as Debug> extern "C" fn(A, B, ...) -> Ret
<extern "C" fn(A, B, C) -> Ret as Debug> extern "C" fn(A, B, C) -> Ret
<extern "C" fn(A, B, C, ...) -> Ret as Debug> extern "C" fn(A, B, C, ...) -> Ret
<extern "C" fn(A, B, C, D) -> Ret as Debug> extern "C" fn(A, B, C, D) -> Ret
and 68 others and 68 others
= note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info) = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)

36
src/test/ui/kindck/kindck-copy.stderr
View file

@ -4,15 +4,15 @@ error[E0277]: the trait bound `&'static mut isize: Copy` is not satisfied
LL | assert_copy::<&'static mut isize>(); LL | assert_copy::<&'static mut isize>();
| ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'static mut isize` | ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'static mut isize`
| |
= help: the following implementations were found: = help: the following other types implement trait `Copy`:
<isize as Copy> f32
<f32 as Copy> f64
<f64 as Copy> i128
<i128 as Copy> i16
<i16 as Copy> i32
<i32 as Copy> i64
<i64 as Copy> i8
<i8 as Copy> isize
and 6 others and 6 others
note: required by a bound in `assert_copy` note: required by a bound in `assert_copy`
--> $DIR/kindck-copy.rs:5:18 --> $DIR/kindck-copy.rs:5:18
@ -26,15 +26,15 @@ error[E0277]: the trait bound `&'a mut isize: Copy` is not satisfied
LL | assert_copy::<&'a mut isize>(); LL | assert_copy::<&'a mut isize>();
| ^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'a mut isize` | ^^^^^^^^^^^^^ the trait `Copy` is not implemented for `&'a mut isize`
| |
= help: the following implementations were found: = help: the following other types implement trait `Copy`:
<isize as Copy> f32
<f32 as Copy> f64
<f64 as Copy> i128
<i128 as Copy> i16
<i16 as Copy> i32
<i32 as Copy> i64
<i64 as Copy> i8
<i8 as Copy> isize
and 6 others and 6 others
note: required by a bound in `assert_copy` note: required by a bound in `assert_copy`
--> $DIR/kindck-copy.rs:5:18 --> $DIR/kindck-copy.rs:5:18

20
src/test/ui/lexer/lex-bad-char-literals-6.stderr
View file

@ -38,15 +38,15 @@ LL | if x == y {}
| ^^ no implementation for `&str == char` | ^^ no implementation for `&str == char`
| |
= help: the trait `PartialEq<char>` is not implemented for `&str` = help: the trait `PartialEq<char>` is not implemented for `&str`
= help: the following implementations were found: = help: the following other types implement trait `PartialEq<Cow<'a, str>>`:
<&'a str as PartialEq<OsString>> <&'a str as PartialEq<OsString>>
<&'a str as PartialEq<String>> <&'a str as PartialEq<String>>
<&'b str as PartialEq<Cow<'a, str>>> <&'b str as PartialEq<Cow<'a, str>>>
<String as PartialEq<&'a str>>
<String as PartialEq<Cow<'a, str>>>
<String as PartialEq<str>>
<String as PartialEq>
<str as PartialEq<Cow<'a, str>>> <str as PartialEq<Cow<'a, str>>>
<str as PartialEq<OsStr>>
<str as PartialEq<OsString>>
<str as PartialEq<String>>
<str as PartialEq>
and 4 others and 4 others
error[E0308]: mismatched types error[E0308]: mismatched types
@ -64,15 +64,15 @@ LL | if x == z {}
| ^^ no implementation for `&str == char` | ^^ no implementation for `&str == char`
| |
= help: the trait `PartialEq<char>` is not implemented for `&str` = help: the trait `PartialEq<char>` is not implemented for `&str`
= help: the following implementations were found: = help: the following other types implement trait `PartialEq<Cow<'a, str>>`:
<&'a str as PartialEq<OsString>> <&'a str as PartialEq<OsString>>
<&'a str as PartialEq<String>> <&'a str as PartialEq<String>>
<&'b str as PartialEq<Cow<'a, str>>> <&'b str as PartialEq<Cow<'a, str>>>
<String as PartialEq<&'a str>>
<String as PartialEq<Cow<'a, str>>>
<String as PartialEq<str>>
<String as PartialEq>
<str as PartialEq<Cow<'a, str>>> <str as PartialEq<Cow<'a, str>>>
<str as PartialEq<OsStr>>
<str as PartialEq<OsString>>
<str as PartialEq<String>>
<str as PartialEq>
and 4 others and 4 others
error: aborting due to 6 previous errors error: aborting due to 6 previous errors

52
src/test/ui/mismatched_types/binops.stderr
View file

@ -5,7 +5,7 @@ LL | 1 + Some(1);
| ^ no implementation for `{integer} + Option<{integer}>` | ^ no implementation for `{integer} + Option<{integer}>`
| |
= 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 implementations were found: = help: the following other types implement trait `Add`:
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
@ -23,15 +23,15 @@ LL | 2 as usize - Some(1);
| ^ no implementation for `usize - Option<{integer}>` | ^ no implementation for `usize - Option<{integer}>`
| |
= 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 implementations were found: = help: the following other types implement trait `Sub`:
<&'a usize as Sub<usize>>
<&usize as Sub<&usize>>
<usize as Sub<&usize>>
<usize as Sub>
<&'a f32 as Sub<f32>> <&'a f32 as Sub<f32>>
<&'a f64 as Sub<f64>> <&'a f64 as Sub<f64>>
<&'a i128 as Sub<i128>> <&'a i128 as Sub<i128>>
<&'a i16 as Sub<i16>> <&'a i16 as Sub<i16>>
<&'a i32 as Sub<i32>>
<&'a i64 as Sub<i64>>
<&'a i8 as Sub<i8>>
<&'a isize as Sub<isize>>
and 48 others and 48 others
error[E0277]: cannot multiply `{integer}` by `()` error[E0277]: cannot multiply `{integer}` by `()`
@ -41,7 +41,7 @@ LL | 3 * ();
| ^ no implementation for `{integer} * ()` | ^ no implementation for `{integer} * ()`
| |
= help: the trait `Mul<()>` is not implemented for `{integer}` = help: the trait `Mul<()>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `Mul`:
<&'a f32 as Mul<f32>> <&'a f32 as Mul<f32>>
<&'a f64 as Mul<f64>> <&'a f64 as Mul<f64>>
<&'a i128 as Mul<i128>> <&'a i128 as Mul<i128>>
@ -59,7 +59,7 @@ LL | 4 / "";
| ^ no implementation for `{integer} / &str` | ^ no implementation for `{integer} / &str`
| |
= help: the trait `Div<&str>` is not implemented for `{integer}` = help: the trait `Div<&str>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `Div`:
<&'a f32 as Div<f32>> <&'a f32 as Div<f32>>
<&'a f64 as Div<f64>> <&'a f64 as Div<f64>>
<&'a i128 as Div<i128>> <&'a i128 as Div<i128>>
@ -77,15 +77,15 @@ LL | 5 < String::new();
| ^ no implementation for `{integer} < String` and `{integer} > String` | ^ no implementation for `{integer} < String` and `{integer} > String`
| |
= help: the trait `PartialOrd<String>` is not implemented for `{integer}` = help: the trait `PartialOrd<String>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `PartialOrd`:
<f32 as PartialOrd> f32
<f64 as PartialOrd> f64
<i128 as PartialOrd> i128
<i16 as PartialOrd> i16
<i32 as PartialOrd> i32
<i64 as PartialOrd> i64
<i8 as PartialOrd> i8
<isize as PartialOrd> isize
and 6 others and 6 others
error[E0277]: can't compare `{integer}` with `Result<{integer}, _>` error[E0277]: can't compare `{integer}` with `Result<{integer}, _>`
@ -95,15 +95,15 @@ LL | 6 == Ok(1);
| ^^ no implementation for `{integer} == Result<{integer}, _>` | ^^ no implementation for `{integer} == Result<{integer}, _>`
| |
= help: the trait `PartialEq<Result<{integer}, _>>` is not implemented for `{integer}` = help: the trait `PartialEq<Result<{integer}, _>>` is not implemented for `{integer}`
= help: the following implementations were found: = help: the following other types implement trait `PartialEq`:
<f32 as PartialEq> f32
<f64 as PartialEq> f64
<i128 as PartialEq> i128
<i16 as PartialEq> i16
<i32 as PartialEq> i32
<i64 as PartialEq> i64
<i8 as PartialEq> i8
<isize as PartialEq> isize
and 6 others and 6 others
error: aborting due to 6 previous errors error: aborting due to 6 previous errors

10
src/test/ui/never_type/issue-13352.stderr
View file

@ -5,15 +5,15 @@ LL | 2_usize + (loop {});
| ^ no implementation for `usize + ()` | ^ no implementation for `usize + ()`
| |
= help: the trait `Add<()>` is not implemented for `usize` = help: the trait `Add<()>` is not implemented for `usize`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a usize as Add<usize>>
<&usize as Add<&usize>>
<usize as Add<&usize>>
<usize as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error: aborting due to previous error error: aborting due to previous error

122
src/test/ui/numbers-arithmetic/not-suggest-float-literal.stderr
View file

@ -5,15 +5,15 @@ LL | x + 100.0
| ^ no implementation for `u8 + {float}` | ^ no implementation for `u8 + {float}`
| |
= help: the trait `Add<{float}>` is not implemented for `u8` = help: the trait `Add<{float}>` is not implemented for `u8`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a u8 as Add<u8>>
<&u8 as Add<&u8>>
<u8 as Add<&u8>>
<u8 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error[E0277]: cannot add `&str` to `f64` error[E0277]: cannot add `&str` to `f64`
@ -23,15 +23,15 @@ LL | x + "foo"
| ^ no implementation for `f64 + &str` | ^ no implementation for `f64 + &str`
| |
= help: the trait `Add<&str>` is not implemented for `f64` = help: the trait `Add<&str>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a f64 as Add<f64>>
<&f64 as Add<&f64>>
<f64 as Add<&f64>>
<f64 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>> <&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error[E0277]: cannot add `{integer}` to `f64` error[E0277]: cannot add `{integer}` to `f64`
@ -41,15 +41,15 @@ LL | x + y
| ^ no implementation for `f64 + {integer}` | ^ no implementation for `f64 + {integer}`
| |
= help: the trait `Add<{integer}>` is not implemented for `f64` = help: the trait `Add<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a f64 as Add<f64>>
<&f64 as Add<&f64>>
<f64 as Add<&f64>>
<f64 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>> <&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error[E0277]: cannot subtract `{float}` from `u8` error[E0277]: cannot subtract `{float}` from `u8`
@ -59,15 +59,15 @@ LL | x - 100.0
| ^ no implementation for `u8 - {float}` | ^ no implementation for `u8 - {float}`
| |
= help: the trait `Sub<{float}>` is not implemented for `u8` = help: the trait `Sub<{float}>` is not implemented for `u8`
= help: the following implementations were found: = help: the following other types implement trait `Sub`:
<&'a u8 as Sub<u8>>
<&u8 as Sub<&u8>>
<u8 as Sub<&u8>>
<u8 as Sub>
<&'a f32 as Sub<f32>> <&'a f32 as Sub<f32>>
<&'a f64 as Sub<f64>> <&'a f64 as Sub<f64>>
<&'a i128 as Sub<i128>> <&'a i128 as Sub<i128>>
<&'a i16 as Sub<i16>> <&'a i16 as Sub<i16>>
<&'a i32 as Sub<i32>>
<&'a i64 as Sub<i64>>
<&'a i8 as Sub<i8>>
<&'a isize as Sub<isize>>
and 48 others and 48 others
error[E0277]: cannot subtract `&str` from `f64` error[E0277]: cannot subtract `&str` from `f64`
@ -77,15 +77,15 @@ LL | x - "foo"
| ^ no implementation for `f64 - &str` | ^ no implementation for `f64 - &str`
| |
= help: the trait `Sub<&str>` is not implemented for `f64` = help: the trait `Sub<&str>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Sub`:
<&'a f64 as Sub<f64>>
<&f64 as Sub<&f64>>
<f64 as Sub<&f64>>
<f64 as Sub>
<&'a f32 as Sub<f32>> <&'a f32 as Sub<f32>>
<&'a f64 as Sub<f64>>
<&'a i128 as Sub<i128>> <&'a i128 as Sub<i128>>
<&'a i16 as Sub<i16>> <&'a i16 as Sub<i16>>
<&'a i32 as Sub<i32>> <&'a i32 as Sub<i32>>
<&'a i64 as Sub<i64>>
<&'a i8 as Sub<i8>>
<&'a isize as Sub<isize>>
and 48 others and 48 others
error[E0277]: cannot subtract `{integer}` from `f64` error[E0277]: cannot subtract `{integer}` from `f64`
@ -95,15 +95,15 @@ LL | x - y
| ^ no implementation for `f64 - {integer}` | ^ no implementation for `f64 - {integer}`
| |
= help: the trait `Sub<{integer}>` is not implemented for `f64` = help: the trait `Sub<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Sub`:
<&'a f64 as Sub<f64>>
<&f64 as Sub<&f64>>
<f64 as Sub<&f64>>
<f64 as Sub>
<&'a f32 as Sub<f32>> <&'a f32 as Sub<f32>>
<&'a f64 as Sub<f64>>
<&'a i128 as Sub<i128>> <&'a i128 as Sub<i128>>
<&'a i16 as Sub<i16>> <&'a i16 as Sub<i16>>
<&'a i32 as Sub<i32>> <&'a i32 as Sub<i32>>
<&'a i64 as Sub<i64>>
<&'a i8 as Sub<i8>>
<&'a isize as Sub<isize>>
and 48 others and 48 others
error[E0277]: cannot multiply `u8` by `{float}` error[E0277]: cannot multiply `u8` by `{float}`
@ -113,15 +113,15 @@ LL | x * 100.0
| ^ no implementation for `u8 * {float}` | ^ no implementation for `u8 * {float}`
| |
= help: the trait `Mul<{float}>` is not implemented for `u8` = help: the trait `Mul<{float}>` is not implemented for `u8`
= help: the following implementations were found: = help: the following other types implement trait `Mul`:
<&'a u8 as Mul<u8>>
<&u8 as Mul<&u8>>
<u8 as Mul<&u8>>
<u8 as Mul>
<&'a f32 as Mul<f32>> <&'a f32 as Mul<f32>>
<&'a f64 as Mul<f64>> <&'a f64 as Mul<f64>>
<&'a i128 as Mul<i128>> <&'a i128 as Mul<i128>>
<&'a i16 as Mul<i16>> <&'a i16 as Mul<i16>>
<&'a i32 as Mul<i32>>
<&'a i64 as Mul<i64>>
<&'a i8 as Mul<i8>>
<&'a isize as Mul<isize>>
and 49 others and 49 others
error[E0277]: cannot multiply `f64` by `&str` error[E0277]: cannot multiply `f64` by `&str`
@ -131,15 +131,15 @@ LL | x * "foo"
| ^ no implementation for `f64 * &str` | ^ no implementation for `f64 * &str`
| |
= help: the trait `Mul<&str>` is not implemented for `f64` = help: the trait `Mul<&str>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Mul`:
<&'a f64 as Mul<f64>>
<&f64 as Mul<&f64>>
<f64 as Mul<&f64>>
<f64 as Mul>
<&'a f32 as Mul<f32>> <&'a f32 as Mul<f32>>
<&'a f64 as Mul<f64>>
<&'a i128 as Mul<i128>> <&'a i128 as Mul<i128>>
<&'a i16 as Mul<i16>> <&'a i16 as Mul<i16>>
<&'a i32 as Mul<i32>> <&'a i32 as Mul<i32>>
<&'a i64 as Mul<i64>>
<&'a i8 as Mul<i8>>
<&'a isize as Mul<isize>>
and 49 others and 49 others
error[E0277]: cannot multiply `f64` by `{integer}` error[E0277]: cannot multiply `f64` by `{integer}`
@ -149,15 +149,15 @@ LL | x * y
| ^ no implementation for `f64 * {integer}` | ^ no implementation for `f64 * {integer}`
| |
= help: the trait `Mul<{integer}>` is not implemented for `f64` = help: the trait `Mul<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Mul`:
<&'a f64 as Mul<f64>>
<&f64 as Mul<&f64>>
<f64 as Mul<&f64>>
<f64 as Mul>
<&'a f32 as Mul<f32>> <&'a f32 as Mul<f32>>
<&'a f64 as Mul<f64>>
<&'a i128 as Mul<i128>> <&'a i128 as Mul<i128>>
<&'a i16 as Mul<i16>> <&'a i16 as Mul<i16>>
<&'a i32 as Mul<i32>> <&'a i32 as Mul<i32>>
<&'a i64 as Mul<i64>>
<&'a i8 as Mul<i8>>
<&'a isize as Mul<isize>>
and 49 others and 49 others
error[E0277]: cannot divide `u8` by `{float}` error[E0277]: cannot divide `u8` by `{float}`
@ -167,15 +167,15 @@ LL | x / 100.0
| ^ no implementation for `u8 / {float}` | ^ no implementation for `u8 / {float}`
| |
= help: the trait `Div<{float}>` is not implemented for `u8` = help: the trait `Div<{float}>` is not implemented for `u8`
= help: the following implementations were found: = help: the following other types implement trait `Div`:
<&'a u8 as Div<u8>>
<&u8 as Div<&u8>>
<u8 as Div<&u8>>
<u8 as Div<NonZeroU8>>
<u8 as Div>
<&'a f32 as Div<f32>> <&'a f32 as Div<f32>>
<&'a f64 as Div<f64>> <&'a f64 as Div<f64>>
<&'a i128 as Div<i128>> <&'a i128 as Div<i128>>
<&'a i16 as Div<i16>>
<&'a i32 as Div<i32>>
<&'a i64 as Div<i64>>
<&'a i8 as Div<i8>>
<&'a isize as Div<isize>>
and 54 others and 54 others
error[E0277]: cannot divide `f64` by `&str` error[E0277]: cannot divide `f64` by `&str`
@ -185,15 +185,15 @@ LL | x / "foo"
| ^ no implementation for `f64 / &str` | ^ no implementation for `f64 / &str`
| |
= help: the trait `Div<&str>` is not implemented for `f64` = help: the trait `Div<&str>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Div`:
<&'a f64 as Div<f64>>
<&f64 as Div<&f64>>
<f64 as Div<&f64>>
<f64 as Div>
<&'a f32 as Div<f32>> <&'a f32 as Div<f32>>
<&'a f64 as Div<f64>>
<&'a i128 as Div<i128>> <&'a i128 as Div<i128>>
<&'a i16 as Div<i16>> <&'a i16 as Div<i16>>
<&'a i32 as Div<i32>> <&'a i32 as Div<i32>>
<&'a i64 as Div<i64>>
<&'a i8 as Div<i8>>
<&'a isize as Div<isize>>
and 54 others and 54 others
error[E0277]: cannot divide `f64` by `{integer}` error[E0277]: cannot divide `f64` by `{integer}`
@ -203,15 +203,15 @@ LL | x / y
| ^ no implementation for `f64 / {integer}` | ^ no implementation for `f64 / {integer}`
| |
= help: the trait `Div<{integer}>` is not implemented for `f64` = help: the trait `Div<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Div`:
<&'a f64 as Div<f64>>
<&f64 as Div<&f64>>
<f64 as Div<&f64>>
<f64 as Div>
<&'a f32 as Div<f32>> <&'a f32 as Div<f32>>
<&'a f64 as Div<f64>>
<&'a i128 as Div<i128>> <&'a i128 as Div<i128>>
<&'a i16 as Div<i16>> <&'a i16 as Div<i16>>
<&'a i32 as Div<i32>> <&'a i32 as Div<i32>>
<&'a i64 as Div<i64>>
<&'a i8 as Div<i8>>
<&'a isize as Div<isize>>
and 54 others and 54 others
error: aborting due to 12 previous errors error: aborting due to 12 previous errors

72
src/test/ui/numbers-arithmetic/suggest-float-literal.stderr
View file

@ -5,15 +5,15 @@ LL | x + 100
| ^ no implementation for `f32 + {integer}` | ^ no implementation for `f32 + {integer}`
| |
= help: the trait `Add<{integer}>` is not implemented for `f32` = help: the trait `Add<{integer}>` is not implemented for `f32`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&f32 as Add<&f32>>
<f32 as Add<&f32>>
<f32 as Add>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>> <&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |
@ -27,15 +27,15 @@ LL | x + 100
| ^ no implementation for `f64 + {integer}` | ^ no implementation for `f64 + {integer}`
| |
= help: the trait `Add<{integer}>` is not implemented for `f64` = help: the trait `Add<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a f64 as Add<f64>>
<&f64 as Add<&f64>>
<f64 as Add<&f64>>
<f64 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>> <&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |
@ -49,15 +49,15 @@ LL | x - 100
| ^ no implementation for `f32 - {integer}` | ^ no implementation for `f32 - {integer}`
| |
= help: the trait `Sub<{integer}>` is not implemented for `f32` = help: the trait `Sub<{integer}>` is not implemented for `f32`
= help: the following implementations were found: = help: the following other types implement trait `Sub`:
<&'a f32 as Sub<f32>> <&'a f32 as Sub<f32>>
<&f32 as Sub<&f32>>
<f32 as Sub<&f32>>
<f32 as Sub>
<&'a f64 as Sub<f64>> <&'a f64 as Sub<f64>>
<&'a i128 as Sub<i128>> <&'a i128 as Sub<i128>>
<&'a i16 as Sub<i16>> <&'a i16 as Sub<i16>>
<&'a i32 as Sub<i32>> <&'a i32 as Sub<i32>>
<&'a i64 as Sub<i64>>
<&'a i8 as Sub<i8>>
<&'a isize as Sub<isize>>
and 48 others and 48 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |
@ -71,15 +71,15 @@ LL | x - 100
| ^ no implementation for `f64 - {integer}` | ^ no implementation for `f64 - {integer}`
| |
= help: the trait `Sub<{integer}>` is not implemented for `f64` = help: the trait `Sub<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Sub`:
<&'a f64 as Sub<f64>>
<&f64 as Sub<&f64>>
<f64 as Sub<&f64>>
<f64 as Sub>
<&'a f32 as Sub<f32>> <&'a f32 as Sub<f32>>
<&'a f64 as Sub<f64>>
<&'a i128 as Sub<i128>> <&'a i128 as Sub<i128>>
<&'a i16 as Sub<i16>> <&'a i16 as Sub<i16>>
<&'a i32 as Sub<i32>> <&'a i32 as Sub<i32>>
<&'a i64 as Sub<i64>>
<&'a i8 as Sub<i8>>
<&'a isize as Sub<isize>>
and 48 others and 48 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |
@ -93,15 +93,15 @@ LL | x * 100
| ^ no implementation for `f32 * {integer}` | ^ no implementation for `f32 * {integer}`
| |
= help: the trait `Mul<{integer}>` is not implemented for `f32` = help: the trait `Mul<{integer}>` is not implemented for `f32`
= help: the following implementations were found: = help: the following other types implement trait `Mul`:
<&'a f32 as Mul<f32>> <&'a f32 as Mul<f32>>
<&f32 as Mul<&f32>>
<f32 as Mul<&f32>>
<f32 as Mul>
<&'a f64 as Mul<f64>> <&'a f64 as Mul<f64>>
<&'a i128 as Mul<i128>> <&'a i128 as Mul<i128>>
<&'a i16 as Mul<i16>> <&'a i16 as Mul<i16>>
<&'a i32 as Mul<i32>> <&'a i32 as Mul<i32>>
<&'a i64 as Mul<i64>>
<&'a i8 as Mul<i8>>
<&'a isize as Mul<isize>>
and 49 others and 49 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |
@ -115,15 +115,15 @@ LL | x * 100
| ^ no implementation for `f64 * {integer}` | ^ no implementation for `f64 * {integer}`
| |
= help: the trait `Mul<{integer}>` is not implemented for `f64` = help: the trait `Mul<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Mul`:
<&'a f64 as Mul<f64>>
<&f64 as Mul<&f64>>
<f64 as Mul<&f64>>
<f64 as Mul>
<&'a f32 as Mul<f32>> <&'a f32 as Mul<f32>>
<&'a f64 as Mul<f64>>
<&'a i128 as Mul<i128>> <&'a i128 as Mul<i128>>
<&'a i16 as Mul<i16>> <&'a i16 as Mul<i16>>
<&'a i32 as Mul<i32>> <&'a i32 as Mul<i32>>
<&'a i64 as Mul<i64>>
<&'a i8 as Mul<i8>>
<&'a isize as Mul<isize>>
and 49 others and 49 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |
@ -137,15 +137,15 @@ LL | x / 100
| ^ no implementation for `f32 / {integer}` | ^ no implementation for `f32 / {integer}`
| |
= help: the trait `Div<{integer}>` is not implemented for `f32` = help: the trait `Div<{integer}>` is not implemented for `f32`
= help: the following implementations were found: = help: the following other types implement trait `Div`:
<&'a f32 as Div<f32>> <&'a f32 as Div<f32>>
<&f32 as Div<&f32>>
<f32 as Div<&f32>>
<f32 as Div>
<&'a f64 as Div<f64>> <&'a f64 as Div<f64>>
<&'a i128 as Div<i128>> <&'a i128 as Div<i128>>
<&'a i16 as Div<i16>> <&'a i16 as Div<i16>>
<&'a i32 as Div<i32>> <&'a i32 as Div<i32>>
<&'a i64 as Div<i64>>
<&'a i8 as Div<i8>>
<&'a isize as Div<isize>>
and 54 others and 54 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |
@ -159,15 +159,15 @@ LL | x / 100
| ^ no implementation for `f64 / {integer}` | ^ no implementation for `f64 / {integer}`
| |
= help: the trait `Div<{integer}>` is not implemented for `f64` = help: the trait `Div<{integer}>` is not implemented for `f64`
= help: the following implementations were found: = help: the following other types implement trait `Div`:
<&'a f64 as Div<f64>>
<&f64 as Div<&f64>>
<f64 as Div<&f64>>
<f64 as Div>
<&'a f32 as Div<f32>> <&'a f32 as Div<f32>>
<&'a f64 as Div<f64>>
<&'a i128 as Div<i128>> <&'a i128 as Div<i128>>
<&'a i16 as Div<i16>> <&'a i16 as Div<i16>>
<&'a i32 as Div<i32>> <&'a i32 as Div<i32>>
<&'a i64 as Div<i64>>
<&'a i8 as Div<i8>>
<&'a isize as Div<isize>>
and 54 others and 54 others
help: consider using a floating-point literal by writing it with `.0` help: consider using a floating-point literal by writing it with `.0`
| |

12
src/test/ui/on-unimplemented/multiple-impls.stderr
View file

@ -7,7 +7,7 @@ LL | Index::index(&[] as &[i32], 2u32);
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the trait `Index<u32>` is not implemented for `[i32]` = help: the trait `Index<u32>` is not implemented for `[i32]`
= help: the following implementations were found: = help: the following other types implement trait `Index<Foo<usize>>`:
<[i32] as Index<Bar<usize>>> <[i32] as Index<Bar<usize>>>
<[i32] as Index<Foo<usize>>> <[i32] as Index<Foo<usize>>>
@ -20,7 +20,7 @@ LL | Index::index(&[] as &[i32], Foo(2u32));
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the trait `Index<Foo<u32>>` is not implemented for `[i32]` = help: the trait `Index<Foo<u32>>` is not implemented for `[i32]`
= help: the following implementations were found: = help: the following other types implement trait `Index<Foo<usize>>`:
<[i32] as Index<Bar<usize>>> <[i32] as Index<Bar<usize>>>
<[i32] as Index<Foo<usize>>> <[i32] as Index<Foo<usize>>>
@ -33,7 +33,7 @@ LL | Index::index(&[] as &[i32], Bar(2u32));
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the trait `Index<Bar<u32>>` is not implemented for `[i32]` = help: the trait `Index<Bar<u32>>` is not implemented for `[i32]`
= help: the following implementations were found: = help: the following other types implement trait `Index<Foo<usize>>`:
<[i32] as Index<Bar<usize>>> <[i32] as Index<Bar<usize>>>
<[i32] as Index<Foo<usize>>> <[i32] as Index<Foo<usize>>>
@ -44,7 +44,7 @@ LL | Index::index(&[] as &[i32], 2u32);
| ^^^^^^^^^^^^ trait message | ^^^^^^^^^^^^ trait message
| |
= help: the trait `Index<u32>` is not implemented for `[i32]` = help: the trait `Index<u32>` is not implemented for `[i32]`
= help: the following implementations were found: = help: the following other types implement trait `Index<Foo<usize>>`:
<[i32] as Index<Bar<usize>>> <[i32] as Index<Bar<usize>>>
<[i32] as Index<Foo<usize>>> <[i32] as Index<Foo<usize>>>
@ -55,7 +55,7 @@ LL | Index::index(&[] as &[i32], Foo(2u32));
| ^^^^^^^^^^^^ on impl for Foo | ^^^^^^^^^^^^ on impl for Foo
| |
= help: the trait `Index<Foo<u32>>` is not implemented for `[i32]` = help: the trait `Index<Foo<u32>>` is not implemented for `[i32]`
= help: the following implementations were found: = help: the following other types implement trait `Index<Foo<usize>>`:
<[i32] as Index<Bar<usize>>> <[i32] as Index<Bar<usize>>>
<[i32] as Index<Foo<usize>>> <[i32] as Index<Foo<usize>>>
@ -66,7 +66,7 @@ LL | Index::index(&[] as &[i32], Bar(2u32));
| ^^^^^^^^^^^^ on impl for Bar | ^^^^^^^^^^^^ on impl for Bar
| |
= help: the trait `Index<Bar<u32>>` is not implemented for `[i32]` = help: the trait `Index<Bar<u32>>` is not implemented for `[i32]`
= help: the following implementations were found: = help: the following other types implement trait `Index<Foo<usize>>`:
<[i32] as Index<Bar<usize>>> <[i32] as Index<Bar<usize>>>
<[i32] as Index<Foo<usize>>> <[i32] as Index<Foo<usize>>>

2
src/test/ui/on-unimplemented/slice-index.stderr
View file

@ -15,7 +15,7 @@ LL | x[..1i32];
| ^^^^^^^^^ slice indices are of type `usize` or ranges of `usize` | ^^^^^^^^^ slice indices are of type `usize` or ranges of `usize`
| |
= help: the trait `SliceIndex<[i32]>` is not implemented for `RangeTo<i32>` = help: the trait `SliceIndex<[i32]>` is not implemented for `RangeTo<i32>`
= help: the following implementations were found: = help: the following other types implement trait `SliceIndex<str>`:
<RangeTo<usize> as SliceIndex<[T]>> <RangeTo<usize> as SliceIndex<[T]>>
<RangeTo<usize> as SliceIndex<str>> <RangeTo<usize> as SliceIndex<str>>
= note: required because of the requirements on the impl of `Index<RangeTo<i32>>` for `[i32]` = note: required because of the requirements on the impl of `Index<RangeTo<i32>>` for `[i32]`

8
src/test/ui/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr
View file

@ -9,10 +9,10 @@ LL | | }
| |_^ `main` can only return types that implement `Termination` | |_^ `main` can only return types that implement `Termination`
| |
= help: the trait `Termination` is not implemented for `Result<f32, ParseFloatError>` = help: the trait `Termination` is not implemented for `Result<f32, ParseFloatError>`
= help: the following implementations were found: = help: the following other types implement trait `Termination`:
<Result<!, E> as Termination> Result<!, E>
<Result<(), E> as Termination> Result<(), E>
<Result<Infallible, E> as Termination> Result<Infallible, E>
note: required by a bound in `assert_test_result` note: required by a bound in `assert_test_result`
--> $SRC_DIR/test/src/lib.rs:LL:COL --> $SRC_DIR/test/src/lib.rs:LL:COL
| |

10
src/test/ui/span/multiline-span-simple.stderr
View file

@ -5,15 +5,15 @@ LL | foo(1 as u32 +
| ^ no implementation for `u32 + ()` | ^ no implementation for `u32 + ()`
| |
= help: the trait `Add<()>` is not implemented for `u32` = help: the trait `Add<()>` is not implemented for `u32`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a u32 as Add<u32>>
<&u32 as Add<&u32>>
<u32 as Add<&u32>>
<u32 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error: aborting due to previous error error: aborting due to previous error

2
src/test/ui/suggestions/into-str.stderr
View file

@ -7,7 +7,7 @@ LL | foo(String::new());
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= note: to coerce a `String` into a `&str`, use `&*` as a prefix = note: to coerce a `String` into a `&str`, use `&*` as a prefix
= help: the following implementations were found: = help: the following other types implement trait `From<char>`:
<String as From<&String>> <String as From<&String>>
<String as From<&mut str>> <String as From<&mut str>>
<String as From<&str>> <String as From<&str>>

2
src/test/ui/suggestions/issue-71394-no-from-impl.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: the trait bound `&[i8]: From<&[u8]>` is not satisfied
LL | let _: &[i8] = data.into(); LL | let _: &[i8] = data.into();
| ^^^^ the trait `From<&[u8]>` is not implemented for `&[i8]` | ^^^^ the trait `From<&[u8]>` is not implemented for `&[i8]`
| |
= help: the following implementations were found: = help: the following other types implement trait `From<Mask<T, LANES>>`:
<[T; LANES] as From<Simd<T, LANES>>> <[T; LANES] as From<Simd<T, LANES>>>
<[bool; LANES] as From<Mask<T, LANES>>> <[bool; LANES] as From<Mask<T, LANES>>>
= note: required because of the requirements on the impl of `Into<&[i8]>` for `&[u8]` = note: required because of the requirements on the impl of `Into<&[i8]>` for `&[u8]`

2
src/test/ui/traits/bound/assoc-fn-bound-root-obligation.rs
View file

@ -4,7 +4,7 @@ fn strip_lf(s: &str) -> &str {
//~| NOTE expected an `FnMut<(char,)>` closure, found `u8` //~| NOTE expected an `FnMut<(char,)>` closure, found `u8`
//~| NOTE required by a bound introduced by this call //~| NOTE required by a bound introduced by this call
//~| HELP the trait `FnMut<(char,)>` is not implemented for `u8` //~| HELP the trait `FnMut<(char,)>` is not implemented for `u8`
//~| HELP the following other types implement trait `Pattern<'_>`: //~| HELP the following other types implement trait `Pattern<'a>`:
//~| NOTE required because of the requirements on the impl of `Pattern<'_>` for `u8` //~| NOTE required because of the requirements on the impl of `Pattern<'_>` for `u8`
} }

2
src/test/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
View file

@ -7,7 +7,7 @@ LL | s.strip_suffix(b'\n').unwrap_or(s)
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the trait `FnMut<(char,)>` is not implemented for `u8` = help: the trait `FnMut<(char,)>` is not implemented for `u8`
= help: the following other types implement trait `Pattern<'_>`: = help: the following other types implement trait `Pattern<'a>`:
&'b String &'b String
&'b [char; N] &'b [char; N]
&'b [char] &'b [char]

10
src/test/ui/traits/inheritance/repeated-supertrait-ambig.stderr
View file

@ -4,7 +4,9 @@ error[E0277]: the trait bound `dyn CompareToInts: CompareTo<i32>` is not satisfi
LL | c.same_as(22) LL | c.same_as(22)
| ^^^^^^^ the trait `CompareTo<i32>` is not implemented for `dyn CompareToInts` | ^^^^^^^ the trait `CompareTo<i32>` is not implemented for `dyn CompareToInts`
| |
= help: the trait `CompareTo<i32>` is implemented for `i64` = help: the following other types implement trait `CompareTo<i64>`:
<i64 as CompareTo<i64>>
<i64 as CompareTo<u64>>
error[E0277]: the trait bound `C: CompareTo<i32>` is not satisfied error[E0277]: the trait bound `C: CompareTo<i32>` is not satisfied
--> $DIR/repeated-supertrait-ambig.rs:30:7 --> $DIR/repeated-supertrait-ambig.rs:30:7
@ -23,7 +25,9 @@ error[E0277]: the trait bound `dyn CompareToInts: CompareTo<i32>` is not satisfi
LL | <dyn CompareToInts>::same_as(c, 22) LL | <dyn CompareToInts>::same_as(c, 22)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `CompareTo<i32>` is not implemented for `dyn CompareToInts` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `CompareTo<i32>` is not implemented for `dyn CompareToInts`
| |
= help: the trait `CompareTo<i32>` is implemented for `i64` = help: the following other types implement trait `CompareTo<i64>`:
<i64 as CompareTo<i64>>
<i64 as CompareTo<u64>>
error[E0277]: the trait bound `C: CompareTo<i32>` is not satisfied error[E0277]: the trait bound `C: CompareTo<i32>` is not satisfied
--> $DIR/repeated-supertrait-ambig.rs:38:5 --> $DIR/repeated-supertrait-ambig.rs:38:5
@ -42,7 +46,7 @@ error[E0277]: the trait bound `i64: CompareTo<i32>` is not satisfied
LL | assert_eq!(22_i64.same_as(22), true); LL | assert_eq!(22_i64.same_as(22), true);
| ^^^^^^^ the trait `CompareTo<i32>` is not implemented for `i64` | ^^^^^^^ the trait `CompareTo<i32>` is not implemented for `i64`
| |
= help: the following implementations were found: = help: the following other types implement trait `CompareTo<i64>`:
<i64 as CompareTo<i64>> <i64 as CompareTo<i64>>
<i64 as CompareTo<u64>> <i64 as CompareTo<u64>>

8
src/test/ui/traits/issue-79458.stderr
View file

@ -7,10 +7,10 @@ LL | struct Foo<'a, T> {
LL | bar: &'a mut T LL | bar: &'a mut T
| ^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `&mut T` | ^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `&mut T`
| |
= help: the following implementations were found: = help: the following other types implement trait `Clone`:
<&T as Clone> &T
<*const T as Clone> *const T
<*mut T as Clone> *mut T
= note: `Clone` is implemented for `&T`, but not for `&mut T` = note: `Clone` is implemented for `&T`, but not for `&mut T`
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info) = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)

2
src/test/ui/traits/map-types.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: the trait bound `Box<dyn Map<isize, isize>>: Map<usize, isize>` is
LL | let y: Box<dyn Map<usize, isize>> = Box::new(x); LL | let y: Box<dyn Map<usize, isize>> = Box::new(x);
| ^^^^^^^^^^^ the trait `Map<usize, isize>` is not implemented for `Box<dyn Map<isize, isize>>` | ^^^^^^^^^^^ the trait `Map<usize, isize>` is not implemented for `Box<dyn Map<isize, isize>>`
| |
= help: the trait `Map<usize, isize>` is implemented for `HashMap<K, V>` = help: the trait `Map<K, V>` is implemented for `HashMap<K, V>`
= note: required for the cast to the object type `dyn Map<usize, isize>` = note: required for the cast to the object type `dyn Map<usize, isize>`
error: aborting due to previous error error: aborting due to previous error

6
src/test/ui/try-trait/bad-interconversion.stderr
View file

@ -7,15 +7,15 @@ LL | Ok(Err(123_i32)?)
| ^ the trait `From<i32>` is not implemented for `u8` | ^ the trait `From<i32>` is not implemented for `u8`
| |
= note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
= help: the following implementations were found: = help: the following other types implement trait `From<bool>`:
<u8 as From<NonZeroU8>>
<u8 as From<bool>>
<f32 as From<i16>> <f32 as From<i16>>
<f32 as From<i8>> <f32 as From<i8>>
<f32 as From<u16>> <f32 as From<u16>>
<f32 as From<u8>> <f32 as From<u8>>
<f64 as From<f32>> <f64 as From<f32>>
<f64 as From<i16>> <f64 as From<i16>>
<f64 as From<i32>>
<f64 as From<i8>>
and 67 others and 67 others
= note: required because of the requirements on the impl of `FromResidual<Result<Infallible, i32>>` for `Result<u64, u8>` = note: required because of the requirements on the impl of `FromResidual<Result<Infallible, i32>>` for `Result<u64, u8>`

2
src/test/ui/type-alias-impl-trait/nested-tait-inference2.stderr
View file

@ -4,7 +4,7 @@ error[E0277]: the trait bound `(): Foo<FooX>` is not satisfied
LL | fn foo() -> impl Foo<FooX> { LL | fn foo() -> impl Foo<FooX> {
| ^^^^^^^^^^^^^^ the trait `Foo<FooX>` is not implemented for `()` | ^^^^^^^^^^^^^^ the trait `Foo<FooX>` is not implemented for `()`
| |
= help: the following implementations were found: = help: the following other types implement trait `Foo<u32>`:
<() as Foo<()>> <() as Foo<()>>
<() as Foo<u32>> <() as Foo<u32>>

10
src/test/ui/type/type-check-defaults.stderr
View file

@ -65,15 +65,15 @@ LL | trait ProjectionPred<T:Iterator = IntoIter<i32>> where T::Item : Add<u8> {}
| ^^^^^^^ no implementation for `i32 + u8` | ^^^^^^^ no implementation for `i32 + u8`
| |
= help: the trait `Add<u8>` is not implemented for `i32` = help: the trait `Add<u8>` is not implemented for `i32`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a i32 as Add<i32>>
<&i32 as Add<&i32>>
<i32 as Add<&i32>>
<i32 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error: aborting due to 7 previous errors error: aborting due to 7 previous errors

10
src/test/ui/typeck/issue-81293.stderr
View file

@ -20,15 +20,15 @@ LL | a = c + b * 5;
| ^ no implementation for `usize + u16` | ^ no implementation for `usize + u16`
| |
= help: the trait `Add<u16>` is not implemented for `usize` = help: the trait `Add<u16>` is not implemented for `usize`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a usize as Add<usize>>
<&usize as Add<&usize>>
<usize as Add<&usize>>
<usize as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error: aborting due to 3 previous errors error: aborting due to 3 previous errors

2
src/test/ui/typeck/issue-90101.stderr
View file

@ -6,7 +6,7 @@ LL | func(Path::new("hello").to_path_buf().to_string_lossy(), "world")
| | | |
| required by a bound introduced by this call | required by a bound introduced by this call
| |
= help: the following implementations were found: = help: the following other types implement trait `From<Box<Path>>`:
<PathBuf as From<&T>> <PathBuf as From<&T>>
<PathBuf as From<Box<Path>>> <PathBuf as From<Box<Path>>>
<PathBuf as From<Cow<'a, Path>>> <PathBuf as From<Cow<'a, Path>>>

10
src/test/ui/ufcs/ufcs-qpath-self-mismatch.stderr
View file

@ -5,15 +5,15 @@ LL | <i32 as Add<u32>>::add(1, 2);
| ^^^^^^^^^^^^^^^^^^^^^^ no implementation for `i32 + u32` | ^^^^^^^^^^^^^^^^^^^^^^ no implementation for `i32 + u32`
| |
= help: the trait `Add<u32>` is not implemented for `i32` = help: the trait `Add<u32>` is not implemented for `i32`
= help: the following implementations were found: = help: the following other types implement trait `Add`:
<&'a i32 as Add<i32>>
<&i32 as Add<&i32>>
<i32 as Add<&i32>>
<i32 as Add>
<&'a f32 as Add<f32>> <&'a f32 as Add<f32>>
<&'a f64 as Add<f64>> <&'a f64 as Add<f64>>
<&'a i128 as Add<i128>> <&'a i128 as Add<i128>>
<&'a i16 as Add<i16>> <&'a i16 as Add<i16>>
<&'a i32 as Add<i32>>
<&'a i64 as Add<i64>>
<&'a i8 as Add<i8>>
<&'a isize as Add<isize>>
and 48 others and 48 others
error[E0308]: mismatched types error[E0308]: mismatched types