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:60: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:64: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:75: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:81: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:82: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:83: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:85: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:85: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:91: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:92: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:93: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:95: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:95: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:105: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:115: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:121: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:123: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:125: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:128: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:128: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:150: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 the macro `mac` (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:154: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 the macro `mac` (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:155: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 the macro `mac` (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    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 208    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 209
 210 error: `...` range patterns are deprecated
 211   --> $DIR/recover-range-pats.rs:45:13
 212    |
 213 LL |     if let 0...Y = 0 {}
 214    |             ^^^ help: use `..=` for an inclusive range
 215    |
 216    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 217    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 218
 219 error: `...` range patterns are deprecated
 220   --> $DIR/recover-range-pats.rs:48:13
 221    |
 222 LL |     if let X...3 = 0 {}
 223    |             ^^^ help: use `..=` for an inclusive range
 224    |
 225    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 226    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 227
 228 error: `...` range patterns are deprecated
 229   --> $DIR/recover-range-pats.rs:51:13
 230    |
 231 LL |     if let X...Y = 0 {}
 232    |             ^^^ help: use `..=` for an inclusive range
 233    |
 234    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 235    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 236
 237 error: `...` range patterns are deprecated
 238   --> $DIR/recover-range-pats.rs:54:16
 239    |
 240 LL |     if let true...Y = 0 {}
 241    |                ^^^ help: use `..=` for an inclusive range
 242    |
 243    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 244    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 245
 246 error: `...` range patterns are deprecated
 247   --> $DIR/recover-range-pats.rs:57:13
 248    |
 249 LL |     if let X...true = 0 {}
 250    |             ^^^ help: use `..=` for an inclusive range
 251    |
 252    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 253    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 254
 255 error: `...` range patterns are deprecated
 256   --> $DIR/recover-range-pats.rs:60:14
 257    |
 258 LL |     if let .0...Y = 0 {}
 259    |              ^^^ help: use `..=` for an inclusive range
 260    |
 261    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 262    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 263
 264 error: `...` range patterns are deprecated
 265   --> $DIR/recover-range-pats.rs:64:13
 266    |
 267 LL |     if let X... .0 = 0 {}
 268    |             ^^^ help: use `..=` for an inclusive range
 269    |
 270    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 271    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 272
 273 error: `...` range patterns are deprecated
 274   --> $DIR/recover-range-pats.rs:138:20
 275    |
 276 LL |             let $e1...$e2;
 277    |                    ^^^ help: use `..=` for an inclusive range
 278 ...
 279 LL |     mac2!(0, 1);
 280    |     ----------- in this macro invocation
 281    |
 282    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 283    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
 284    = note: this error originates in the macro `mac2` (in Nightly builds, run with -Z macro-backtrace for more info)
 285
 286 error[E0029]: only `char` and numeric types are allowed in range patterns
 287   --> $DIR/recover-range-pats.rs:20:12
 288    |
 289 LL |     if let true..Y = 0 {}
 290    |            ^^^^  - this is of type `u8`
 291    |            |
 292    |            this is of type `bool` but it should be `char` or numeric
 293
 294 error[E0029]: only `char` and numeric types are allowed in range patterns
 295   --> $DIR/recover-range-pats.rs:21:15
 296    |
 297 LL |     if let X..true = 0 {}
 298    |            -  ^^^^ this is of type `bool` but it should be `char` or numeric
 299    |            |
 300    |            this is of type `u8`
 301
 302 error[E0308]: mismatched types
 303   --> $DIR/recover-range-pats.rs:22:12
 304    |
 305 LL |     if let .0..Y = 0 {}
 306    |            ^^  -   - this expression has type `{integer}`
 307    |            |   |
 308    |            |   this is of type `u8`
 309    |            expected integer, found floating-point number
 310
 311 error[E0308]: mismatched types
 312   --> $DIR/recover-range-pats.rs:24:16
 313    |
 314 LL |     if let X.. .0 = 0 {}
 315    |            -   ^^   - this expression has type `u8`
 316    |            |   |
 317    |            |   expected integer, found floating-point number
 318    |            this is of type `u8`
 319    |
 320    = note: expected type `u8`
 321               found type `{float}`
 322
 323 error[E0029]: only `char` and numeric types are allowed in range patterns
 324   --> $DIR/recover-range-pats.rs:33:12
 325    |
 326 LL |     if let true..=Y = 0 {}
 327    |            ^^^^   - this is of type `u8`
 328    |            |
 329    |            this is of type `bool` but it should be `char` or numeric
 330
 331 error[E0029]: only `char` and numeric types are allowed in range patterns
 332   --> $DIR/recover-range-pats.rs:34:16
 333    |
 334 LL |     if let X..=true = 0 {}
 335    |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
 336    |            |
 337    |            this is of type `u8`
 338
 339 error[E0308]: mismatched types
 340   --> $DIR/recover-range-pats.rs:35:12
 341    |
 342 LL |     if let .0..=Y = 0 {}
 343    |            ^^   -   - this expression has type `{integer}`
 344    |            |    |
 345    |            |    this is of type `u8`
 346    |            expected integer, found floating-point number
 347
 348 error[E0308]: mismatched types
 349   --> $DIR/recover-range-pats.rs:37:16
 350    |
 351 LL |     if let X..=.0 = 0 {}
 352    |            -   ^^   - this expression has type `u8`
 353    |            |   |
 354    |            |   expected integer, found floating-point number
 355    |            this is of type `u8`
 356    |
 357    = note: expected type `u8`
 358               found type `{float}`
 359
 360 error[E0029]: only `char` and numeric types are allowed in range patterns
 361   --> $DIR/recover-range-pats.rs:54:12
 362    |
 363 LL |     if let true...Y = 0 {}
 364    |            ^^^^   - this is of type `u8`
 365    |            |
 366    |            this is of type `bool` but it should be `char` or numeric
 367
 368 error[E0029]: only `char` and numeric types are allowed in range patterns
 369   --> $DIR/recover-range-pats.rs:57:16
 370    |
 371 LL |     if let X...true = 0 {}
 372    |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
 373    |            |
 374    |            this is of type `u8`
 375
 376 error[E0308]: mismatched types
 377   --> $DIR/recover-range-pats.rs:60:12
 378    |
 379 LL |     if let .0...Y = 0 {}
 380    |            ^^   -   - this expression has type `{integer}`
 381    |            |    |
 382    |            |    this is of type `u8`
 383    |            expected integer, found floating-point number
 384
 385 error[E0308]: mismatched types
 386   --> $DIR/recover-range-pats.rs:64:17
 387    |
 388 LL |     if let X... .0 = 0 {}
 389    |            -    ^^   - this expression has type `u8`
 390    |            |    |
 391    |            |    expected integer, found floating-point number
 392    |            this is of type `u8`
 393    |
 394    = note: expected type `u8`
 395               found type `{float}`
 396
 397 error[E0029]: only `char` and numeric types are allowed in range patterns
 398   --> $DIR/recover-range-pats.rs:73:12
 399    |
 400 LL |     if let true.. = 0 {}
 401    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 402
 403 error[E0308]: mismatched types
 404   --> $DIR/recover-range-pats.rs:75:12
 405    |
 406 LL |     if let .0.. = 0 {}
 407    |            ^^     - this expression has type `{integer}`
 408    |            |
 409    |            expected integer, found floating-point number
 410
 411 error[E0029]: only `char` and numeric types are allowed in range patterns
 412   --> $DIR/recover-range-pats.rs:83:12
 413    |
 414 LL |     if let true..= = 0 {}
 415    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 416
 417 error[E0308]: mismatched types
 418   --> $DIR/recover-range-pats.rs:85:12
 419    |
 420 LL |     if let .0..= = 0 {}
 421    |            ^^      - this expression has type `{integer}`
 422    |            |
 423    |            expected integer, found floating-point number
 424
 425 error[E0029]: only `char` and numeric types are allowed in range patterns
 426   --> $DIR/recover-range-pats.rs:93:12
 427    |
 428 LL |     if let true... = 0 {}
 429    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 430
 431 error[E0308]: mismatched types
 432   --> $DIR/recover-range-pats.rs:95:12
 433    |
 434 LL |     if let .0... = 0 {}
 435    |            ^^      - this expression has type `{integer}`
 436    |            |
 437    |            expected integer, found floating-point number
 438
 439 error[E0029]: only `char` and numeric types are allowed in range patterns
 440   --> $DIR/recover-range-pats.rs:103:14
 441    |
 442 LL |     if let ..true = 0 {}
 443    |              ^^^^ this is of type `bool` but it should be `char` or numeric
 444
 445 error[E0308]: mismatched types
 446   --> $DIR/recover-range-pats.rs:105:15
 447    |
 448 LL |     if let .. .0 = 0 {}
 449    |               ^^   - this expression has type `{integer}`
 450    |               |
 451    |               expected integer, found floating-point number
 452
 453 error[E0029]: only `char` and numeric types are allowed in range patterns
 454   --> $DIR/recover-range-pats.rs:113:15
 455    |
 456 LL |     if let ..=true = 0 {}
 457    |               ^^^^ this is of type `bool` but it should be `char` or numeric
 458
 459 error[E0308]: mismatched types
 460   --> $DIR/recover-range-pats.rs:115:15
 461    |
 462 LL |     if let ..=.0 = 0 {}
 463    |               ^^   - this expression has type `{integer}`
 464    |               |
 465    |               expected integer, found floating-point number
 466
 467 error[E0029]: only `char` and numeric types are allowed in range patterns
 468   --> $DIR/recover-range-pats.rs:125:15
 469    |
 470 LL |     if let ...true = 0 {}
 471    |               ^^^^ this is of type `bool` but it should be `char` or numeric
 472
 473 error[E0308]: mismatched types
 474   --> $DIR/recover-range-pats.rs:128:15
 475    |
 476 LL |     if let ....3 = 0 {}
 477    |               ^^   - this expression has type `{integer}`
 478    |               |
 479    |               expected integer, found floating-point number
 480
 481 error: aborting due to 60 previous errors
 482
 483 Some errors have detailed explanations: E0029, E0308, E0586.
 484 For more information about an error, try `rustc --explain E0029`.