error[E0369]: cannot add `A` to `A`
  --> $DIR/issue-28837.rs:6:7
   |
LL |     a + a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `Add<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `Add<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
   |
LL | / pub trait Add<Rhs = Self> {
LL | |     /// The resulting type after applying the `+` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn add(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: cannot subtract `A` from `A`
  --> $DIR/issue-28837.rs:8:7
   |
LL |     a - a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `Sub<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `Sub<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
   |
LL | / pub trait Sub<Rhs = Self> {
LL | |     /// The resulting type after applying the `-` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn sub(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: cannot multiply `A` by `A`
  --> $DIR/issue-28837.rs:10:7
   |
LL |     a * a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `Mul<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `Mul<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
   |
LL | / pub trait Mul<Rhs = Self> {
LL | |     /// The resulting type after applying the `*` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn mul(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: cannot divide `A` by `A`
  --> $DIR/issue-28837.rs:12:7
   |
LL |     a / a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `Div<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `Div<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
   |
LL | / pub trait Div<Rhs = Self> {
LL | |     /// The resulting type after applying the `/` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn div(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: cannot mod `A` by `A`
  --> $DIR/issue-28837.rs:14:7
   |
LL |     a % a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `Rem<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `Rem<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
   |
LL | / pub trait Rem<Rhs = Self> {
LL | |     /// The resulting type after applying the `%` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn rem(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: no implementation for `A & A`
  --> $DIR/issue-28837.rs:16:7
   |
LL |     a & a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `BitAnd<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `BitAnd<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
   |
LL | / pub trait BitAnd<Rhs = Self> {
LL | |     /// The resulting type after applying the `&` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn bitand(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: no implementation for `A | A`
  --> $DIR/issue-28837.rs:18:7
   |
LL |     a | a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `BitOr<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `BitOr<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
   |
LL | / pub trait BitOr<Rhs = Self> {
LL | |     /// The resulting type after applying the `|` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn bitor(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: no implementation for `A << A`
  --> $DIR/issue-28837.rs:20:7
   |
LL |     a << a;
   |     - ^^ - A
   |     |
   |     A
   |
note: an implementation of `Shl<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `Shl<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
   |
LL | / pub trait Shl<Rhs = Self> {
LL | |     /// The resulting type after applying the `<<` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn shl(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: no implementation for `A >> A`
  --> $DIR/issue-28837.rs:22:7
   |
LL |     a >> a;
   |     - ^^ - A
   |     |
   |     A
   |
note: an implementation of `Shr<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `Shr<_>`
note: the following trait must be implemented
  --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
   |
LL | / pub trait Shr<Rhs = Self> {
LL | |     /// The resulting type after applying the `>>` operator.
LL | |     #[stable(feature = "rust1", since = "1.0.0")]
LL | |     type Output;
...  |
LL | |     fn shr(self, rhs: Rhs) -> Self::Output;
LL | | }
   | |_^

error[E0369]: binary operation `==` cannot be applied to type `A`
  --> $DIR/issue-28837.rs:24:7
   |
LL |     a == a;
   |     - ^^ - A
   |     |
   |     A
   |
note: an implementation of `PartialEq<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `PartialEq<_>`
help: consider annotating `A` with `#[derive(PartialEq)]`
   |
LL | #[derive(PartialEq)]
   |

error[E0369]: binary operation `!=` cannot be applied to type `A`
  --> $DIR/issue-28837.rs:26:7
   |
LL |     a != a;
   |     - ^^ - A
   |     |
   |     A
   |
note: an implementation of `PartialEq<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `PartialEq<_>`
help: consider annotating `A` with `#[derive(PartialEq)]`
   |
LL | #[derive(PartialEq)]
   |

error[E0369]: binary operation `<` cannot be applied to type `A`
  --> $DIR/issue-28837.rs:28:7
   |
LL |     a < a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `PartialOrd<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `PartialOrd<_>`
help: consider annotating `A` with `#[derive(PartialOrd)]`
   |
LL | #[derive(PartialOrd)]
   |

error[E0369]: binary operation `<=` cannot be applied to type `A`
  --> $DIR/issue-28837.rs:30:7
   |
LL |     a <= a;
   |     - ^^ - A
   |     |
   |     A
   |
note: an implementation of `PartialOrd<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `PartialOrd<_>`
help: consider annotating `A` with `#[derive(PartialOrd)]`
   |
LL | #[derive(PartialOrd)]
   |

error[E0369]: binary operation `>` cannot be applied to type `A`
  --> $DIR/issue-28837.rs:32:7
   |
LL |     a > a;
   |     - ^ - A
   |     |
   |     A
   |
note: an implementation of `PartialOrd<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `PartialOrd<_>`
help: consider annotating `A` with `#[derive(PartialOrd)]`
   |
LL | #[derive(PartialOrd)]
   |

error[E0369]: binary operation `>=` cannot be applied to type `A`
  --> $DIR/issue-28837.rs:34:7
   |
LL |     a >= a;
   |     - ^^ - A
   |     |
   |     A
   |
note: an implementation of `PartialOrd<_>` might be missing for `A`
  --> $DIR/issue-28837.rs:1:1
   |
LL | struct A;
   | ^^^^^^^^^ must implement `PartialOrd<_>`
help: consider annotating `A` with `#[derive(PartialOrd)]`
   |
LL | #[derive(PartialOrd)]
   |

error: aborting due to 15 previous errors

For more information about this error, try `rustc --explain E0369`.