src/test/ui/parser/recover-range-pats.stderr

   1 error: float literals must have an integer part
   2   --> $DIR/recover-range-pats.rs:22:12
   3    |
   4 LL |     if let .0..Y = 0 {}
   5    |            ^^ help: must have an integer part: `0.0`
   6
   7 error: float literals must have an integer part
   8   --> $DIR/recover-range-pats.rs:24:16
   9    |
  10 LL |     if let X.. .0 = 0 {}
  11    |                ^^ help: must have an integer part: `0.0`
  12
  13 error: float literals must have an integer part
  14   --> $DIR/recover-range-pats.rs:35:12
  15    |
  16 LL |     if let .0..=Y = 0 {}
  17    |            ^^ help: must have an integer part: `0.0`
  18
  19 error: float literals must have an integer part
  20   --> $DIR/recover-range-pats.rs:37:16
  21    |
  22 LL |     if let X..=.0 = 0 {}
  23    |                ^^ help: must have an integer part: `0.0`
  24
  25 error: float literals must have an integer part
  26   --> $DIR/recover-range-pats.rs:50:12
  27    |
  28 LL |     if let .0...Y = 0 {}
  29    |            ^^ help: must have an integer part: `0.0`
  30
  31 error: float literals must have an integer part
  32   --> $DIR/recover-range-pats.rs:53:17
  33    |
  34 LL |     if let X... .0 = 0 {}
  35    |                 ^^ help: must have an integer part: `0.0`
  36
  37 error: float literals must have an integer part
  38   --> $DIR/recover-range-pats.rs:63:12
  39    |
  40 LL |     if let .0.. = 0 {}
  41    |            ^^ help: must have an integer part: `0.0`
  42
  43 error[E0586]: inclusive range with no end
  44   --> $DIR/recover-range-pats.rs:69:13
  45    |
  46 LL |     if let 0..= = 0 {}
  47    |             ^^^ help: use `..` instead
  48    |
  49    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
  50
  51 error[E0586]: inclusive range with no end
  52   --> $DIR/recover-range-pats.rs:70:13
  53    |
  54 LL |     if let X..= = 0 {}
  55    |             ^^^ help: use `..` instead
  56    |
  57    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
  58
  59 error[E0586]: inclusive range with no end
  60   --> $DIR/recover-range-pats.rs:71:16
  61    |
  62 LL |     if let true..= = 0 {}
  63    |                ^^^ help: use `..` instead
  64    |
  65    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
  66
  67 error: float literals must have an integer part
  68   --> $DIR/recover-range-pats.rs:73:12
  69    |
  70 LL |     if let .0..= = 0 {}
  71    |            ^^ help: must have an integer part: `0.0`
  72
  73 error[E0586]: inclusive range with no end
  74   --> $DIR/recover-range-pats.rs:73:14
  75    |
  76 LL |     if let .0..= = 0 {}
  77    |              ^^^ help: use `..` instead
  78    |
  79    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
  80
  81 error[E0586]: inclusive range with no end
  82   --> $DIR/recover-range-pats.rs:79:13
  83    |
  84 LL |     if let 0... = 0 {}
  85    |             ^^^ help: use `..` instead
  86    |
  87    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
  88
  89 error[E0586]: inclusive range with no end
  90   --> $DIR/recover-range-pats.rs:80:13
  91    |
  92 LL |     if let X... = 0 {}
  93    |             ^^^ help: use `..` instead
  94    |
  95    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
  96
  97 error[E0586]: inclusive range with no end
  98   --> $DIR/recover-range-pats.rs:81:16
  99    |
 100 LL |     if let true... = 0 {}
 101    |                ^^^ help: use `..` instead
 102    |
 103    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 104
 105 error: float literals must have an integer part
 106   --> $DIR/recover-range-pats.rs:83:12
 107    |
 108 LL |     if let .0... = 0 {}
 109    |            ^^ help: must have an integer part: `0.0`
 110
 111 error[E0586]: inclusive range with no end
 112   --> $DIR/recover-range-pats.rs:83:14
 113    |
 114 LL |     if let .0... = 0 {}
 115    |              ^^^ help: use `..` instead
 116    |
 117    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 118
 119 error: float literals must have an integer part
 120   --> $DIR/recover-range-pats.rs:93:15
 121    |
 122 LL |     if let .. .0 = 0 {}
 123    |               ^^ help: must have an integer part: `0.0`
 124
 125 error: float literals must have an integer part
 126   --> $DIR/recover-range-pats.rs:103:15
 127    |
 128 LL |     if let ..=.0 = 0 {}
 129    |               ^^ help: must have an integer part: `0.0`
 130
 131 error: range-to patterns with `...` are not allowed
 132   --> $DIR/recover-range-pats.rs:109:12
 133    |
 134 LL |     if let ...3 = 0 {}
 135    |            ^^^ help: use `..=` instead
 136
 137 error: range-to patterns with `...` are not allowed
 138   --> $DIR/recover-range-pats.rs:111:12
 139    |
 140 LL |     if let ...Y = 0 {}
 141    |            ^^^ help: use `..=` instead
 142
 143 error: range-to patterns with `...` are not allowed
 144   --> $DIR/recover-range-pats.rs:113:12
 145    |
 146 LL |     if let ...true = 0 {}
 147    |            ^^^ help: use `..=` instead
 148
 149 error: float literals must have an integer part
 150   --> $DIR/recover-range-pats.rs:116:15
 151    |
 152 LL |     if let ....3 = 0 {}
 153    |               ^^ help: must have an integer part: `0.3`
 154
 155 error: range-to patterns with `...` are not allowed
 156   --> $DIR/recover-range-pats.rs:116:12
 157    |
 158 LL |     if let ....3 = 0 {}
 159    |            ^^^ help: use `..=` instead
 160
 161 error: range-to patterns with `...` are not allowed
 162   --> $DIR/recover-range-pats.rs:137:17
 163    |
 164 LL |             let ...$e;
 165    |                 ^^^ help: use `..=` instead
 166 ...
 167 LL |     mac!(0);
 168    |     -------- in this macro invocation
 169    |
 170    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 171
 172 error[E0586]: inclusive range with no end
 173   --> $DIR/recover-range-pats.rs:141:19
 174    |
 175 LL |             let $e...;
 176    |                   ^^^ help: use `..` instead
 177 ...
 178 LL |     mac!(0);
 179    |     -------- in this macro invocation
 180    |
 181    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 182    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 183
 184 error[E0586]: inclusive range with no end
 185   --> $DIR/recover-range-pats.rs:142:19
 186    |
 187 LL |             let $e..=;
 188    |                   ^^^ help: use `..` instead
 189 ...
 190 LL |     mac!(0);
 191    |     -------- in this macro invocation
 192    |
 193    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 194    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 195
 196 error: `...` range patterns are deprecated
 197   --> $DIR/recover-range-pats.rs:42:13
 198    |
 199 LL |     if let 0...3 = 0 {}
 200    |             ^^^ help: use `..=` for an inclusive range
 201    |
 202 note: the lint level is defined here
 203   --> $DIR/recover-range-pats.rs:8:9
 204    |
 205 LL | #![deny(ellipsis_inclusive_range_patterns)]
 206    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 207
 208 error: `...` range patterns are deprecated
 209   --> $DIR/recover-range-pats.rs:43:13
 210    |
 211 LL |     if let 0...Y = 0 {}
 212    |             ^^^ help: use `..=` for an inclusive range
 213
 214 error: `...` range patterns are deprecated
 215   --> $DIR/recover-range-pats.rs:44:13
 216    |
 217 LL |     if let X...3 = 0 {}
 218    |             ^^^ help: use `..=` for an inclusive range
 219
 220 error: `...` range patterns are deprecated
 221   --> $DIR/recover-range-pats.rs:45:13
 222    |
 223 LL |     if let X...Y = 0 {}
 224    |             ^^^ help: use `..=` for an inclusive range
 225
 226 error: `...` range patterns are deprecated
 227   --> $DIR/recover-range-pats.rs:46:16
 228    |
 229 LL |     if let true...Y = 0 {}
 230    |                ^^^ help: use `..=` for an inclusive range
 231
 232 error: `...` range patterns are deprecated
 233   --> $DIR/recover-range-pats.rs:48:13
 234    |
 235 LL |     if let X...true = 0 {}
 236    |             ^^^ help: use `..=` for an inclusive range
 237
 238 error: `...` range patterns are deprecated
 239   --> $DIR/recover-range-pats.rs:50:14
 240    |
 241 LL |     if let .0...Y = 0 {}
 242    |              ^^^ help: use `..=` for an inclusive range
 243
 244 error: `...` range patterns are deprecated
 245   --> $DIR/recover-range-pats.rs:53:13
 246    |
 247 LL |     if let X... .0 = 0 {}
 248    |             ^^^ help: use `..=` for an inclusive range
 249
 250 error: `...` range patterns are deprecated
 251   --> $DIR/recover-range-pats.rs:126:20
 252    |
 253 LL |             let $e1...$e2;
 254    |                    ^^^ help: use `..=` for an inclusive range
 255 ...
 256 LL |     mac2!(0, 1);
 257    |     ------------ in this macro invocation
 258    |
 259    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 260
 261 error[E0029]: only char and numeric types are allowed in range patterns
 262   --> $DIR/recover-range-pats.rs:20:12
 263    |
 264 LL |     if let true..Y = 0 {}
 265    |            ^^^^  - this is of type `u8`
 266    |            |
 267    |            this is of type `bool` but it should be `char` or numeric
 268
 269 error[E0029]: only char and numeric types are allowed in range patterns
 270   --> $DIR/recover-range-pats.rs:21:15
 271    |
 272 LL |     if let X..true = 0 {}
 273    |            -  ^^^^ this is of type `bool` but it should be `char` or numeric
 274    |            |
 275    |            this is of type `u8`
 276
 277 error[E0308]: mismatched types
 278   --> $DIR/recover-range-pats.rs:22:12
 279    |
 280 LL |     if let .0..Y = 0 {}
 281    |            ^^  - this is of type `u8`
 282    |            |
 283    |            expected integer, found floating-point number
 284
 285 error[E0308]: mismatched types
 286   --> $DIR/recover-range-pats.rs:24:16
 287    |
 288 LL |     if let X.. .0 = 0 {}
 289    |            -   ^^   - this expression has type `u8`
 290    |            |   |
 291    |            |   expected integer, found floating-point number
 292    |            this is of type `u8`
 293
 294 error[E0029]: only char and numeric types are allowed in range patterns
 295   --> $DIR/recover-range-pats.rs:33:12
 296    |
 297 LL |     if let true..=Y = 0 {}
 298    |            ^^^^   - this is of type `u8`
 299    |            |
 300    |            this is of type `bool` but it should be `char` or numeric
 301
 302 error[E0029]: only char and numeric types are allowed in range patterns
 303   --> $DIR/recover-range-pats.rs:34:16
 304    |
 305 LL |     if let X..=true = 0 {}
 306    |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
 307    |            |
 308    |            this is of type `u8`
 309
 310 error[E0308]: mismatched types
 311   --> $DIR/recover-range-pats.rs:35:12
 312    |
 313 LL |     if let .0..=Y = 0 {}
 314    |            ^^   - this is of type `u8`
 315    |            |
 316    |            expected integer, found floating-point number
 317
 318 error[E0308]: mismatched types
 319   --> $DIR/recover-range-pats.rs:37:16
 320    |
 321 LL |     if let X..=.0 = 0 {}
 322    |            -   ^^   - this expression has type `u8`
 323    |            |   |
 324    |            |   expected integer, found floating-point number
 325    |            this is of type `u8`
 326
 327 error[E0029]: only char and numeric types are allowed in range patterns
 328   --> $DIR/recover-range-pats.rs:46:12
 329    |
 330 LL |     if let true...Y = 0 {}
 331    |            ^^^^   - this is of type `u8`
 332    |            |
 333    |            this is of type `bool` but it should be `char` or numeric
 334
 335 error[E0029]: only char and numeric types are allowed in range patterns
 336   --> $DIR/recover-range-pats.rs:48:16
 337    |
 338 LL |     if let X...true = 0 {}
 339    |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
 340    |            |
 341    |            this is of type `u8`
 342
 343 error[E0308]: mismatched types
 344   --> $DIR/recover-range-pats.rs:50:12
 345    |
 346 LL |     if let .0...Y = 0 {}
 347    |            ^^   - this is of type `u8`
 348    |            |
 349    |            expected integer, found floating-point number
 350
 351 error[E0308]: mismatched types
 352   --> $DIR/recover-range-pats.rs:53:17
 353    |
 354 LL |     if let X... .0 = 0 {}
 355    |            -    ^^   - this expression has type `u8`
 356    |            |    |
 357    |            |    expected integer, found floating-point number
 358    |            this is of type `u8`
 359
 360 error[E0029]: only char and numeric types are allowed in range patterns
 361   --> $DIR/recover-range-pats.rs:61:12
 362    |
 363 LL |     if let true.. = 0 {}
 364    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 365
 366 error[E0308]: mismatched types
 367   --> $DIR/recover-range-pats.rs:63:12
 368    |
 369 LL |     if let .0.. = 0 {}
 370    |            ^^ expected integer, found floating-point number
 371
 372 error[E0029]: only char and numeric types are allowed in range patterns
 373   --> $DIR/recover-range-pats.rs:71:12
 374    |
 375 LL |     if let true..= = 0 {}
 376    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 377
 378 error[E0308]: mismatched types
 379   --> $DIR/recover-range-pats.rs:73:12
 380    |
 381 LL |     if let .0..= = 0 {}
 382    |            ^^ expected integer, found floating-point number
 383
 384 error[E0029]: only char and numeric types are allowed in range patterns
 385   --> $DIR/recover-range-pats.rs:81:12
 386    |
 387 LL |     if let true... = 0 {}
 388    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 389
 390 error[E0308]: mismatched types
 391   --> $DIR/recover-range-pats.rs:83:12
 392    |
 393 LL |     if let .0... = 0 {}
 394    |            ^^ expected integer, found floating-point number
 395
 396 error[E0029]: only char and numeric types are allowed in range patterns
 397   --> $DIR/recover-range-pats.rs:91:14
 398    |
 399 LL |     if let ..true = 0 {}
 400    |              ^^^^ this is of type `bool` but it should be `char` or numeric
 401
 402 error[E0308]: mismatched types
 403   --> $DIR/recover-range-pats.rs:93:15
 404    |
 405 LL |     if let .. .0 = 0 {}
 406    |               ^^ expected integer, found floating-point number
 407
 408 error[E0029]: only char and numeric types are allowed in range patterns
 409   --> $DIR/recover-range-pats.rs:101:15
 410    |
 411 LL |     if let ..=true = 0 {}
 412    |               ^^^^ this is of type `bool` but it should be `char` or numeric
 413
 414 error[E0308]: mismatched types
 415   --> $DIR/recover-range-pats.rs:103:15
 416    |
 417 LL |     if let ..=.0 = 0 {}
 418    |               ^^ expected integer, found floating-point number
 419
 420 error[E0029]: only char and numeric types are allowed in range patterns
 421   --> $DIR/recover-range-pats.rs:113:15
 422    |
 423 LL |     if let ...true = 0 {}
 424    |               ^^^^ this is of type `bool` but it should be `char` or numeric
 425
 426 error[E0308]: mismatched types
 427   --> $DIR/recover-range-pats.rs:116:15
 428    |
 429 LL |     if let ....3 = 0 {}
 430    |               ^^ expected integer, found floating-point number
 431
 432 error: aborting due to 60 previous errors
 433
 434 Some errors have detailed explanations: E0029, E0308, E0586.
 435 For more information about an error, try `rustc --explain E0029`.