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