src/test/ui/binop/issue-28837.stderr

   1 error[E0369]: cannot add `A` to `A`
   2   --> $DIR/issue-28837.rs:6:7
   3    |
   4 LL |     a + a;
   5    |     - ^ - A
   6    |     |
   7    |     A
   8    |
   9 note: an implementation of `Add<_>` might be missing for `A`
  10   --> $DIR/issue-28837.rs:1:1
  11    |
  12 LL | struct A;
  13    | ^^^^^^^^^ must implement `Add<_>`
  14 note: the following trait must be implemented
  15   --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
  16    |
  17 LL | / pub trait Add<Rhs = Self> {
  18 LL | |     /// The resulting type after applying the `+` operator.
  19 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
  20 LL | |     type Output;
  21 ...  |
  22 LL | |     fn add(self, rhs: Rhs) -> Self::Output;
  23 LL | | }
  24    | |_^
  25
  26 error[E0369]: cannot subtract `A` from `A`
  27   --> $DIR/issue-28837.rs:8:7
  28    |
  29 LL |     a - a;
  30    |     - ^ - A
  31    |     |
  32    |     A
  33    |
  34 note: an implementation of `Sub<_>` might be missing for `A`
  35   --> $DIR/issue-28837.rs:1:1
  36    |
  37 LL | struct A;
  38    | ^^^^^^^^^ must implement `Sub<_>`
  39 note: the following trait must be implemented
  40   --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
  41    |
  42 LL | / pub trait Sub<Rhs = Self> {
  43 LL | |     /// The resulting type after applying the `-` operator.
  44 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
  45 LL | |     type Output;
  46 ...  |
  47 LL | |     fn sub(self, rhs: Rhs) -> Self::Output;
  48 LL | | }
  49    | |_^
  50
  51 error[E0369]: cannot multiply `A` by `A`
  52   --> $DIR/issue-28837.rs:10:7
  53    |
  54 LL |     a * a;
  55    |     - ^ - A
  56    |     |
  57    |     A
  58    |
  59 note: an implementation of `Mul<_>` might be missing for `A`
  60   --> $DIR/issue-28837.rs:1:1
  61    |
  62 LL | struct A;
  63    | ^^^^^^^^^ must implement `Mul<_>`
  64 note: the following trait must be implemented
  65   --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
  66    |
  67 LL | / pub trait Mul<Rhs = Self> {
  68 LL | |     /// The resulting type after applying the `*` operator.
  69 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
  70 LL | |     type Output;
  71 ...  |
  72 LL | |     fn mul(self, rhs: Rhs) -> Self::Output;
  73 LL | | }
  74    | |_^
  75
  76 error[E0369]: cannot divide `A` by `A`
  77   --> $DIR/issue-28837.rs:12:7
  78    |
  79 LL |     a / a;
  80    |     - ^ - A
  81    |     |
  82    |     A
  83    |
  84 note: an implementation of `Div<_>` might be missing for `A`
  85   --> $DIR/issue-28837.rs:1:1
  86    |
  87 LL | struct A;
  88    | ^^^^^^^^^ must implement `Div<_>`
  89 note: the following trait must be implemented
  90   --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
  91    |
  92 LL | / pub trait Div<Rhs = Self> {
  93 LL | |     /// The resulting type after applying the `/` operator.
  94 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
  95 LL | |     type Output;
  96 ...  |
  97 LL | |     fn div(self, rhs: Rhs) -> Self::Output;
  98 LL | | }
  99    | |_^
 100
 101 error[E0369]: cannot mod `A` by `A`
 102   --> $DIR/issue-28837.rs:14:7
 103    |
 104 LL |     a % a;
 105    |     - ^ - A
 106    |     |
 107    |     A
 108    |
 109 note: an implementation of `Rem<_>` might be missing for `A`
 110   --> $DIR/issue-28837.rs:1:1
 111    |
 112 LL | struct A;
 113    | ^^^^^^^^^ must implement `Rem<_>`
 114 note: the following trait must be implemented
 115   --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
 116    |
 117 LL | / pub trait Rem<Rhs = Self> {
 118 LL | |     /// The resulting type after applying the `%` operator.
 119 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
 120 LL | |     type Output;
 121 ...  |
 122 LL | |     fn rem(self, rhs: Rhs) -> Self::Output;
 123 LL | | }
 124    | |_^
 125
 126 error[E0369]: no implementation for `A & A`
 127   --> $DIR/issue-28837.rs:16:7
 128    |
 129 LL |     a & a;
 130    |     - ^ - A
 131    |     |
 132    |     A
 133    |
 134 note: an implementation of `BitAnd<_>` might be missing for `A`
 135   --> $DIR/issue-28837.rs:1:1
 136    |
 137 LL | struct A;
 138    | ^^^^^^^^^ must implement `BitAnd<_>`
 139 note: the following trait must be implemented
 140   --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
 141    |
 142 LL | / pub trait BitAnd<Rhs = Self> {
 143 LL | |     /// The resulting type after applying the `&` operator.
 144 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
 145 LL | |     type Output;
 146 ...  |
 147 LL | |     fn bitand(self, rhs: Rhs) -> Self::Output;
 148 LL | | }
 149    | |_^
 150
 151 error[E0369]: no implementation for `A | A`
 152   --> $DIR/issue-28837.rs:18:7
 153    |
 154 LL |     a | a;
 155    |     - ^ - A
 156    |     |
 157    |     A
 158    |
 159 note: an implementation of `BitOr<_>` might be missing for `A`
 160   --> $DIR/issue-28837.rs:1:1
 161    |
 162 LL | struct A;
 163    | ^^^^^^^^^ must implement `BitOr<_>`
 164 note: the following trait must be implemented
 165   --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
 166    |
 167 LL | / pub trait BitOr<Rhs = Self> {
 168 LL | |     /// The resulting type after applying the `|` operator.
 169 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
 170 LL | |     type Output;
 171 ...  |
 172 LL | |     fn bitor(self, rhs: Rhs) -> Self::Output;
 173 LL | | }
 174    | |_^
 175
 176 error[E0369]: no implementation for `A << A`
 177   --> $DIR/issue-28837.rs:20:7
 178    |
 179 LL |     a << a;
 180    |     - ^^ - A
 181    |     |
 182    |     A
 183    |
 184 note: an implementation of `Shl<_>` might be missing for `A`
 185   --> $DIR/issue-28837.rs:1:1
 186    |
 187 LL | struct A;
 188    | ^^^^^^^^^ must implement `Shl<_>`
 189 note: the following trait must be implemented
 190   --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
 191    |
 192 LL | / pub trait Shl<Rhs = Self> {
 193 LL | |     /// The resulting type after applying the `<<` operator.
 194 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
 195 LL | |     type Output;
 196 ...  |
 197 LL | |     fn shl(self, rhs: Rhs) -> Self::Output;
 198 LL | | }
 199    | |_^
 200
 201 error[E0369]: no implementation for `A >> A`
 202   --> $DIR/issue-28837.rs:22:7
 203    |
 204 LL |     a >> a;
 205    |     - ^^ - A
 206    |     |
 207    |     A
 208    |
 209 note: an implementation of `Shr<_>` might be missing for `A`
 210   --> $DIR/issue-28837.rs:1:1
 211    |
 212 LL | struct A;
 213    | ^^^^^^^^^ must implement `Shr<_>`
 214 note: the following trait must be implemented
 215   --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
 216    |
 217 LL | / pub trait Shr<Rhs = Self> {
 218 LL | |     /// The resulting type after applying the `>>` operator.
 219 LL | |     #[stable(feature = "rust1", since = "1.0.0")]
 220 LL | |     type Output;
 221 ...  |
 222 LL | |     fn shr(self, rhs: Rhs) -> Self::Output;
 223 LL | | }
 224    | |_^
 225
 226 error[E0369]: binary operation `==` cannot be applied to type `A`
 227   --> $DIR/issue-28837.rs:24:7
 228    |
 229 LL |     a == a;
 230    |     - ^^ - A
 231    |     |
 232    |     A
 233    |
 234 note: an implementation of `PartialEq<_>` might be missing for `A`
 235   --> $DIR/issue-28837.rs:1:1
 236    |
 237 LL | struct A;
 238    | ^^^^^^^^^ must implement `PartialEq<_>`
 239 help: consider annotating `A` with `#[derive(PartialEq)]`
 240    |
 241 LL | #[derive(PartialEq)]
 242    |
 243
 244 error[E0369]: binary operation `!=` cannot be applied to type `A`
 245   --> $DIR/issue-28837.rs:26:7
 246    |
 247 LL |     a != a;
 248    |     - ^^ - A
 249    |     |
 250    |     A
 251    |
 252 note: an implementation of `PartialEq<_>` might be missing for `A`
 253   --> $DIR/issue-28837.rs:1:1
 254    |
 255 LL | struct A;
 256    | ^^^^^^^^^ must implement `PartialEq<_>`
 257 help: consider annotating `A` with `#[derive(PartialEq)]`
 258    |
 259 LL | #[derive(PartialEq)]
 260    |
 261
 262 error[E0369]: binary operation `<` cannot be applied to type `A`
 263   --> $DIR/issue-28837.rs:28:7
 264    |
 265 LL |     a < a;
 266    |     - ^ - A
 267    |     |
 268    |     A
 269    |
 270 note: an implementation of `PartialOrd<_>` might be missing for `A`
 271   --> $DIR/issue-28837.rs:1:1
 272    |
 273 LL | struct A;
 274    | ^^^^^^^^^ must implement `PartialOrd<_>`
 275 help: consider annotating `A` with `#[derive(PartialOrd)]`
 276    |
 277 LL | #[derive(PartialOrd)]
 278    |
 279
 280 error[E0369]: binary operation `<=` cannot be applied to type `A`
 281   --> $DIR/issue-28837.rs:30:7
 282    |
 283 LL |     a <= a;
 284    |     - ^^ - A
 285    |     |
 286    |     A
 287    |
 288 note: an implementation of `PartialOrd<_>` might be missing for `A`
 289   --> $DIR/issue-28837.rs:1:1
 290    |
 291 LL | struct A;
 292    | ^^^^^^^^^ must implement `PartialOrd<_>`
 293 help: consider annotating `A` with `#[derive(PartialOrd)]`
 294    |
 295 LL | #[derive(PartialOrd)]
 296    |
 297
 298 error[E0369]: binary operation `>` cannot be applied to type `A`
 299   --> $DIR/issue-28837.rs:32:7
 300    |
 301 LL |     a > a;
 302    |     - ^ - A
 303    |     |
 304    |     A
 305    |
 306 note: an implementation of `PartialOrd<_>` might be missing for `A`
 307   --> $DIR/issue-28837.rs:1:1
 308    |
 309 LL | struct A;
 310    | ^^^^^^^^^ must implement `PartialOrd<_>`
 311 help: consider annotating `A` with `#[derive(PartialOrd)]`
 312    |
 313 LL | #[derive(PartialOrd)]
 314    |
 315
 316 error[E0369]: binary operation `>=` cannot be applied to type `A`
 317   --> $DIR/issue-28837.rs:34:7
 318    |
 319 LL |     a >= a;
 320    |     - ^^ - A
 321    |     |
 322    |     A
 323    |
 324 note: an implementation of `PartialOrd<_>` might be missing for `A`
 325   --> $DIR/issue-28837.rs:1:1
 326    |
 327 LL | struct A;
 328    | ^^^^^^^^^ must implement `PartialOrd<_>`
 329 help: consider annotating `A` with `#[derive(PartialOrd)]`
 330    |
 331 LL | #[derive(PartialOrd)]
 332    |
 333
 334 error: aborting due to 15 previous errors
 335
 336 For more information about this error, try `rustc --explain E0369`.