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 error[E0029]: only `char` and numeric types are allowed in range patterns
 321   --> $DIR/recover-range-pats.rs:33:12
 322    |
 323 LL |     if let true..=Y = 0 {}
 324    |            ^^^^   - this is of type `u8`
 325    |            |
 326    |            this is of type `bool` but it should be `char` or numeric
 327
 328 error[E0029]: only `char` and numeric types are allowed in range patterns
 329   --> $DIR/recover-range-pats.rs:34:16
 330    |
 331 LL |     if let X..=true = 0 {}
 332    |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
 333    |            |
 334    |            this is of type `u8`
 335
 336 error[E0308]: mismatched types
 337   --> $DIR/recover-range-pats.rs:35:12
 338    |
 339 LL |     if let .0..=Y = 0 {}
 340    |            ^^   -   - this expression has type `{integer}`
 341    |            |    |
 342    |            |    this is of type `u8`
 343    |            expected integer, found floating-point number
 344
 345 error[E0308]: mismatched types
 346   --> $DIR/recover-range-pats.rs:37:16
 347    |
 348 LL |     if let X..=.0 = 0 {}
 349    |            -   ^^   - this expression has type `u8`
 350    |            |   |
 351    |            |   expected integer, found floating-point number
 352    |            this is of type `u8`
 353
 354 error[E0029]: only `char` and numeric types are allowed in range patterns
 355   --> $DIR/recover-range-pats.rs:54:12
 356    |
 357 LL |     if let true...Y = 0 {}
 358    |            ^^^^   - this is of type `u8`
 359    |            |
 360    |            this is of type `bool` but it should be `char` or numeric
 361
 362 error[E0029]: only `char` and numeric types are allowed in range patterns
 363   --> $DIR/recover-range-pats.rs:57:16
 364    |
 365 LL |     if let X...true = 0 {}
 366    |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
 367    |            |
 368    |            this is of type `u8`
 369
 370 error[E0308]: mismatched types
 371   --> $DIR/recover-range-pats.rs:60:12
 372    |
 373 LL |     if let .0...Y = 0 {}
 374    |            ^^   -   - this expression has type `{integer}`
 375    |            |    |
 376    |            |    this is of type `u8`
 377    |            expected integer, found floating-point number
 378
 379 error[E0308]: mismatched types
 380   --> $DIR/recover-range-pats.rs:64:17
 381    |
 382 LL |     if let X... .0 = 0 {}
 383    |            -    ^^   - this expression has type `u8`
 384    |            |    |
 385    |            |    expected integer, found floating-point number
 386    |            this is of type `u8`
 387
 388 error[E0029]: only `char` and numeric types are allowed in range patterns
 389   --> $DIR/recover-range-pats.rs:73:12
 390    |
 391 LL |     if let true.. = 0 {}
 392    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 393
 394 error[E0308]: mismatched types
 395   --> $DIR/recover-range-pats.rs:75:12
 396    |
 397 LL |     if let .0.. = 0 {}
 398    |            ^^     - this expression has type `{integer}`
 399    |            |
 400    |            expected integer, found floating-point number
 401
 402 error[E0029]: only `char` and numeric types are allowed in range patterns
 403   --> $DIR/recover-range-pats.rs:83:12
 404    |
 405 LL |     if let true..= = 0 {}
 406    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 407
 408 error[E0308]: mismatched types
 409   --> $DIR/recover-range-pats.rs:85:12
 410    |
 411 LL |     if let .0..= = 0 {}
 412    |            ^^      - this expression has type `{integer}`
 413    |            |
 414    |            expected integer, found floating-point number
 415
 416 error[E0029]: only `char` and numeric types are allowed in range patterns
 417   --> $DIR/recover-range-pats.rs:93:12
 418    |
 419 LL |     if let true... = 0 {}
 420    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 421
 422 error[E0308]: mismatched types
 423   --> $DIR/recover-range-pats.rs:95:12
 424    |
 425 LL |     if let .0... = 0 {}
 426    |            ^^      - this expression has type `{integer}`
 427    |            |
 428    |            expected integer, found floating-point number
 429
 430 error[E0029]: only `char` and numeric types are allowed in range patterns
 431   --> $DIR/recover-range-pats.rs:103:14
 432    |
 433 LL |     if let ..true = 0 {}
 434    |              ^^^^ this is of type `bool` but it should be `char` or numeric
 435
 436 error[E0308]: mismatched types
 437   --> $DIR/recover-range-pats.rs:105:15
 438    |
 439 LL |     if let .. .0 = 0 {}
 440    |               ^^   - this expression has type `{integer}`
 441    |               |
 442    |               expected integer, found floating-point number
 443
 444 error[E0029]: only `char` and numeric types are allowed in range patterns
 445   --> $DIR/recover-range-pats.rs:113:15
 446    |
 447 LL |     if let ..=true = 0 {}
 448    |               ^^^^ this is of type `bool` but it should be `char` or numeric
 449
 450 error[E0308]: mismatched types
 451   --> $DIR/recover-range-pats.rs:115:15
 452    |
 453 LL |     if let ..=.0 = 0 {}
 454    |               ^^   - this expression has type `{integer}`
 455    |               |
 456    |               expected integer, found floating-point number
 457
 458 error[E0029]: only `char` and numeric types are allowed in range patterns
 459   --> $DIR/recover-range-pats.rs:125:15
 460    |
 461 LL |     if let ...true = 0 {}
 462    |               ^^^^ this is of type `bool` but it should be `char` or numeric
 463
 464 error[E0308]: mismatched types
 465   --> $DIR/recover-range-pats.rs:128:15
 466    |
 467 LL |     if let ....3 = 0 {}
 468    |               ^^   - this expression has type `{integer}`
 469    |               |
 470    |               expected integer, found floating-point number
 471
 472 error: aborting due to 60 previous errors
 473
 474 Some errors have detailed explanations: E0029, E0308, E0586.
 475 For more information about an error, try `rustc --explain E0029`.