dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Provide RHS type hint when reporting operator error

This commit is contained in:
Michael Goulet 2023-04-27 00:57:13 +00:00
parent 3d80dd983d
commit 015acc2611
20 changed files with 137 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
compiler/rustc_hir_typeck/src/op.rs
View File

@ -776,6 +776,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Ok(method)
}
None => {
// This path may do some inference, so make sure we've really
// doomed compilation so as to not accidentally stabilize new
// inference or something here...
self.tcx.sess.delay_span_bug(span, "this path really should be doomed...");
// Guide inference for the RHS expression if it's provided --
// this will allow us to better error reporting, at the expense
// of making some error messages a bit more specific.
if let Some((rhs_expr, rhs_ty)) = opt_rhs
&& rhs_ty.is_ty_var()
{
self.check_expr_coercible_to_type(rhs_expr, rhs_ty, None);
}
let (obligation, _) =
self.obligation_for_method(cause, trait_did, lhs_ty, Some(input_types));
// FIXME: This should potentially just add the obligation to the `FnCtxt`

7
tests/ui/binop/eq-arr.rs Normal file
View File

@ -0,0 +1,7 @@
fn main() {
struct X;
//~^ HELP consider annotating `X` with `#[derive(PartialEq)]`
let xs = [X, X, X];
let eq = xs == [X, X, X];
//~^ ERROR binary operation `==` cannot be applied to type `[X; 3]`
}

22
tests/ui/binop/eq-arr.stderr Normal file
View File

@ -0,0 +1,22 @@
error[E0369]: binary operation `==` cannot be applied to type `[X; 3]`
--> $DIR/eq-arr.rs:5:17
|
LL | let eq = xs == [X, X, X];
| -- ^^ --------- [X; 3]
| |
| [X; 3]
|
note: an implementation of `PartialEq` might be missing for `X`
--> $DIR/eq-arr.rs:2:5
|
LL | struct X;
| ^^^^^^^^ must implement `PartialEq`
help: consider annotating `X` with `#[derive(PartialEq)]`
|
LL + #[derive(PartialEq)]
LL | struct X;
|
error: aborting due to previous error
For more information about this error, try `rustc --explain E0369`.

13
tests/ui/binop/eq-vec.rs Normal file
View File

@ -0,0 +1,13 @@
fn main() {
#[derive(Debug)]
enum Foo {
//~^ HELP consider annotating `Foo` with `#[derive(PartialEq)]`
Bar,
Qux,
}
let vec1 = vec![Foo::Bar, Foo::Qux];
let vec2 = vec![Foo::Bar, Foo::Qux];
assert_eq!(vec1, vec2);
//~^ ERROR binary operation `==` cannot be applied to type `Vec<Foo>`
}

24
tests/ui/binop/eq-vec.stderr Normal file
View File

@ -0,0 +1,24 @@
error[E0369]: binary operation `==` cannot be applied to type `Vec<Foo>`
--> $DIR/eq-vec.rs:11:5
|
LL | assert_eq!(vec1, vec2);
| ^^^^^^^^^^^^^^^^^^^^^^
| |
| Vec<Foo>
| Vec<Foo>
|
note: an implementation of `PartialEq` might be missing for `Foo`
--> $DIR/eq-vec.rs:3:5
|
LL | enum Foo {
| ^^^^^^^^ must implement `PartialEq`
= note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `Foo` with `#[derive(PartialEq)]`
|
LL + #[derive(PartialEq)]
LL | enum Foo {
|
error: aborting due to previous error
For more information about this error, try `rustc --explain E0369`.

60
tests/ui/binop/issue-28837.stderr
View File

@ -6,11 +6,11 @@ LL | a + a;
| |
| A
|
note: an implementation of `Add<_>` might be missing for `A`
note: an implementation of `Add` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `Add<_>`
| ^^^^^^^^ must implement `Add`
note: the trait `Add` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
@ -22,11 +22,11 @@ LL | a - a;
| |
| A
|
note: an implementation of `Sub<_>` might be missing for `A`
note: an implementation of `Sub` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `Sub<_>`
| ^^^^^^^^ must implement `Sub`
note: the trait `Sub` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
@ -38,11 +38,11 @@ LL | a * a;
| |
| A
|
note: an implementation of `Mul<_>` might be missing for `A`
note: an implementation of `Mul` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `Mul<_>`
| ^^^^^^^^ must implement `Mul`
note: the trait `Mul` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
@ -54,11 +54,11 @@ LL | a / a;
| |
| A
|
note: an implementation of `Div<_>` might be missing for `A`
note: an implementation of `Div` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `Div<_>`
| ^^^^^^^^ must implement `Div`
note: the trait `Div` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
@ -70,11 +70,11 @@ LL | a % a;
| |
| A
|
note: an implementation of `Rem<_>` might be missing for `A`
note: an implementation of `Rem` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `Rem<_>`
| ^^^^^^^^ must implement `Rem`
note: the trait `Rem` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
@ -86,11 +86,11 @@ LL | a & a;
| |
| A
|
note: an implementation of `BitAnd<_>` might be missing for `A`
note: an implementation of `BitAnd` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `BitAnd<_>`
| ^^^^^^^^ must implement `BitAnd`
note: the trait `BitAnd` must be implemented
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
@ -102,11 +102,11 @@ LL | a | a;
| |
| A
|
note: an implementation of `BitOr<_>` might be missing for `A`
note: an implementation of `BitOr` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `BitOr<_>`
| ^^^^^^^^ must implement `BitOr`
note: the trait `BitOr` must be implemented
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
@ -118,11 +118,11 @@ LL | a << a;
| |
| A
|
note: an implementation of `Shl<_>` might be missing for `A`
note: an implementation of `Shl` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `Shl<_>`
| ^^^^^^^^ must implement `Shl`
note: the trait `Shl` must be implemented
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
@ -134,11 +134,11 @@ LL | a >> a;
| |
| A
|
note: an implementation of `Shr<_>` might be missing for `A`
note: an implementation of `Shr` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `Shr<_>`
| ^^^^^^^^ must implement `Shr`
note: the trait `Shr` must be implemented
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL
@ -150,11 +150,11 @@ LL | a == a;
| |
| A
|
note: an implementation of `PartialEq<_>` might be missing for `A`
note: an implementation of `PartialEq` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `PartialEq<_>`
| ^^^^^^^^ must implement `PartialEq`
help: consider annotating `A` with `#[derive(PartialEq)]`
|
LL + #[derive(PartialEq)]
@ -169,11 +169,11 @@ LL | a != a;
| |
| A
|
note: an implementation of `PartialEq<_>` might be missing for `A`
note: an implementation of `PartialEq` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `PartialEq<_>`
| ^^^^^^^^ must implement `PartialEq`
help: consider annotating `A` with `#[derive(PartialEq)]`
|
LL + #[derive(PartialEq)]
@ -188,11 +188,11 @@ LL | a < a;
| |
| A
|
note: an implementation of `PartialOrd<_>` might be missing for `A`
note: an implementation of `PartialOrd` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `PartialOrd<_>`
| ^^^^^^^^ must implement `PartialOrd`
help: consider annotating `A` with `#[derive(PartialEq, PartialOrd)]`
|
LL + #[derive(PartialEq, PartialOrd)]
@ -207,11 +207,11 @@ LL | a <= a;
| |
| A
|
note: an implementation of `PartialOrd<_>` might be missing for `A`
note: an implementation of `PartialOrd` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `PartialOrd<_>`
| ^^^^^^^^ must implement `PartialOrd`
help: consider annotating `A` with `#[derive(PartialEq, PartialOrd)]`
|
LL + #[derive(PartialEq, PartialOrd)]
@ -226,11 +226,11 @@ LL | a > a;
| |
| A
|
note: an implementation of `PartialOrd<_>` might be missing for `A`
note: an implementation of `PartialOrd` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `PartialOrd<_>`
| ^^^^^^^^ must implement `PartialOrd`
help: consider annotating `A` with `#[derive(PartialEq, PartialOrd)]`
|
LL + #[derive(PartialEq, PartialOrd)]
@ -245,11 +245,11 @@ LL | a >= a;
| |
| A
|
note: an implementation of `PartialOrd<_>` might be missing for `A`
note: an implementation of `PartialOrd` might be missing for `A`
--> $DIR/issue-28837.rs:1:1
|
LL | struct A;
| ^^^^^^^^ must implement `PartialOrd<_>`
| ^^^^^^^^ must implement `PartialOrd`
help: consider annotating `A` with `#[derive(PartialEq, PartialOrd)]`
|
LL + #[derive(PartialEq, PartialOrd)]

4
tests/ui/binop/issue-3820.stderr
View File

@ -6,11 +6,11 @@ LL | let w = u * 3;
| |
| Thing
|
note: an implementation of `Mul<_>` might be missing for `Thing`
note: an implementation of `Mul<{integer}>` might be missing for `Thing`
--> $DIR/issue-3820.rs:1:1
|
LL | struct Thing {
| ^^^^^^^^^^^^ must implement `Mul<_>`
| ^^^^^^^^^^^^ must implement `Mul<{integer}>`
note: the trait `Mul` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL

4
tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
View File

@ -7,11 +7,11 @@ LL | #[derive(PartialEq)]
LL | x: Error
| ^^^^^^^^
|
note: an implementation of `PartialEq<_>` might be missing for `Error`
note: an implementation of `PartialEq` might be missing for `Error`
--> $DIR/derives-span-PartialEq-enum-struct-variant.rs:4:1
|
LL | struct Error;
| ^^^^^^^^^^^^ must implement `PartialEq<_>`
| ^^^^^^^^^^^^ must implement `PartialEq`
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `Error` with `#[derive(PartialEq)]`
|

4
tests/ui/derives/derives-span-PartialEq-enum.stderr
View File

@ -7,11 +7,11 @@ LL | #[derive(PartialEq)]
LL | Error
| ^^^^^
|
note: an implementation of `PartialEq<_>` might be missing for `Error`
note: an implementation of `PartialEq` might be missing for `Error`
--> $DIR/derives-span-PartialEq-enum.rs:4:1
|
LL | struct Error;
| ^^^^^^^^^^^^ must implement `PartialEq<_>`
| ^^^^^^^^^^^^ must implement `PartialEq`
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `Error` with `#[derive(PartialEq)]`
|

4
tests/ui/derives/derives-span-PartialEq-struct.stderr
View File

@ -7,11 +7,11 @@ LL | struct Struct {
LL | x: Error
| ^^^^^^^^
|
note: an implementation of `PartialEq<_>` might be missing for `Error`
note: an implementation of `PartialEq` might be missing for `Error`
--> $DIR/derives-span-PartialEq-struct.rs:4:1
|
LL | struct Error;
| ^^^^^^^^^^^^ must implement `PartialEq<_>`
| ^^^^^^^^^^^^ must implement `PartialEq`
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `Error` with `#[derive(PartialEq)]`
|

4
tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr
View File

@ -7,11 +7,11 @@ LL | struct Struct(
LL | Error
| ^^^^^
|
note: an implementation of `PartialEq<_>` might be missing for `Error`
note: an implementation of `PartialEq` might be missing for `Error`
--> $DIR/derives-span-PartialEq-tuple-struct.rs:4:1
|
LL | struct Error;
| ^^^^^^^^^^^^ must implement `PartialEq<_>`
| ^^^^^^^^^^^^ must implement `PartialEq`
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `Error` with `#[derive(PartialEq)]`
|

4
tests/ui/derives/deriving-no-inner-impl-error-message.stderr
View File

@ -7,11 +7,11 @@ LL | struct E {
LL | x: NoCloneOrEq
| ^^^^^^^^^^^^^^
|
note: an implementation of `PartialEq<_>` might be missing for `NoCloneOrEq`
note: an implementation of `PartialEq` might be missing for `NoCloneOrEq`
--> $DIR/deriving-no-inner-impl-error-message.rs:1:1
|
LL | struct NoCloneOrEq;
| ^^^^^^^^^^^^^^^^^^ must implement `PartialEq<_>`
| ^^^^^^^^^^^^^^^^^^ must implement `PartialEq`
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `NoCloneOrEq` with `#[derive(PartialEq)]`
|

4
tests/ui/destructuring-assignment/note-unsupported.stderr
View File

@ -44,11 +44,11 @@ LL | S { x: a, y: b } += s;
| |
| cannot use `+=` on type `S`
|
note: an implementation of `AddAssign<_>` might be missing for `S`
note: an implementation of `AddAssign` might be missing for `S`
--> $DIR/note-unsupported.rs:1:1
|
LL | struct S { x: u8, y: u8 }
| ^^^^^^^^ must implement `AddAssign<_>`
| ^^^^^^^^ must implement `AddAssign`
note: the trait `AddAssign` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL

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

@ -6,11 +6,11 @@ LL | a == A::Value;
| |
| A
|
note: an implementation of `PartialEq<_>` might be missing for `A`
note: an implementation of `PartialEq<fn(()) -> A {A::Value}>` might be missing for `A`
--> $DIR/issue-62375.rs:1:1
|
LL | enum A {
| ^^^^^^ must implement `PartialEq<_>`
| ^^^^^^ must implement `PartialEq<fn(()) -> A {A::Value}>`
help: consider annotating `A` with `#[derive(PartialEq)]`
|
LL + #[derive(PartialEq)]

4
tests/ui/mismatched_types/assignment-operator-unimplemented.stderr
View File

@ -6,11 +6,11 @@ LL | a += *b;
| |
| cannot use `+=` on type `Foo`
|
note: an implementation of `AddAssign<_>` might be missing for `Foo`
note: an implementation of `AddAssign` might be missing for `Foo`
--> $DIR/assignment-operator-unimplemented.rs:1:1
|
LL | struct Foo;
| ^^^^^^^^^^ must implement `AddAssign<_>`
| ^^^^^^^^^^ must implement `AddAssign`
note: the trait `AddAssign` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL

4
tests/ui/or-patterns/or-patterns-syntactic-fail.stderr
View File

@ -30,11 +30,11 @@ LL | let _ = |A | B: E| ();
| |
| E
|
note: an implementation of `BitOr<_>` might be missing for `E`
note: an implementation of `BitOr<()>` might be missing for `E`
--> $DIR/or-patterns-syntactic-fail.rs:6:1
|
LL | enum E { A, B }
| ^^^^^^ must implement `BitOr<_>`
| ^^^^^^ must implement `BitOr<()>`
note: the trait `BitOr` must be implemented
--> $SRC_DIR/core/src/ops/bit.rs:LL:COL

4
tests/ui/span/issue-39018.stderr
View File

@ -21,11 +21,11 @@ LL | let y = World::Hello + World::Goodbye;
| |
| World
|
note: an implementation of `Add<_>` might be missing for `World`
note: an implementation of `Add` might be missing for `World`
--> $DIR/issue-39018.rs:15:1
|
LL | enum World {
| ^^^^^^^^^^ must implement `Add<_>`
| ^^^^^^^^^^ must implement `Add`
note: the trait `Add` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL

4
tests/ui/suggestions/invalid-bin-op.stderr
View File

@ -6,11 +6,11 @@ LL | let _ = s == t;
| |
| S<T>
|
note: an implementation of `PartialEq<_>` might be missing for `S<T>`
note: an implementation of `PartialEq` might be missing for `S<T>`
--> $DIR/invalid-bin-op.rs:5:1
|
LL | struct S<T>(T);
| ^^^^^^^^^^^ must implement `PartialEq<_>`
| ^^^^^^^^^^^ must implement `PartialEq`
help: consider annotating `S<T>` with `#[derive(PartialEq)]`
|
LL + #[derive(PartialEq)]

4
tests/ui/suggestions/restrict-type-not-param.stderr
View File

@ -6,11 +6,11 @@ LL | a + b
| |
| Wrapper<T>
|
note: an implementation of `Add<_>` might be missing for `Wrapper<T>`
note: an implementation of `Add<T>` might be missing for `Wrapper<T>`
--> $DIR/restrict-type-not-param.rs:3:1
|
LL | struct Wrapper<T>(T);
| ^^^^^^^^^^^^^^^^^ must implement `Add<_>`
| ^^^^^^^^^^^^^^^^^ must implement `Add<T>`
note: the trait `Add` must be implemented
--> $SRC_DIR/core/src/ops/arith.rs:LL:COL
help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement

4
tests/ui/type/type-unsatisfiable.usage.stderr
View File

@ -1,8 +1,8 @@
error[E0369]: cannot subtract `(dyn Vector2<ScalarType = i32> + 'static)` from `dyn Vector2<ScalarType = i32>`
error[E0369]: cannot subtract `dyn Vector2<ScalarType = i32>` from `dyn Vector2<ScalarType = i32>`
--> $DIR/type-unsatisfiable.rs:57:20
|
LL | let bar = *hey - *word;
| ---- ^ ----- (dyn Vector2<ScalarType = i32> + 'static)
| ---- ^ ----- dyn Vector2<ScalarType = i32>
| |
| dyn Vector2<ScalarType = i32>