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

   1 error: float literals must have an integer part
   2   --> $DIR/recover-range-pats.rs:21: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:23: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:34: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:36: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:49: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:52:17
  33    |
  34 LL |     if let X... .0 = 0 {}
  35    |                 ^^ help: must have an integer part: `0.0`
  36
  37 error: `X..` range patterns are not supported
  38   --> $DIR/recover-range-pats.rs:58:12
  39    |
  40 LL |     if let 0.. = 0 {}
  41    |            ^^^ help: try using the maximum value for the type: `0..MAX`
  42
  43 error: `X..` range patterns are not supported
  44   --> $DIR/recover-range-pats.rs:59:12
  45    |
  46 LL |     if let X.. = 0 {}
  47    |            ^^^ help: try using the maximum value for the type: `X..MAX`
  48
  49 error: `X..` range patterns are not supported
  50   --> $DIR/recover-range-pats.rs:60:12
  51    |
  52 LL |     if let true.. = 0 {}
  53    |            ^^^^^^ help: try using the maximum value for the type: `true..MAX`
  54
  55 error: float literals must have an integer part
  56   --> $DIR/recover-range-pats.rs:62:12
  57    |
  58 LL |     if let .0.. = 0 {}
  59    |            ^^ help: must have an integer part: `0.0`
  60
  61 error: `X..` range patterns are not supported
  62   --> $DIR/recover-range-pats.rs:62:12
  63    |
  64 LL |     if let .0.. = 0 {}
  65    |            ^^^^ help: try using the maximum value for the type: `0.0..MAX`
  66
  67 error: `X..=` range patterns are not supported
  68   --> $DIR/recover-range-pats.rs:68:12
  69    |
  70 LL |     if let 0..= = 0 {}
  71    |            ^^^^ help: try using the maximum value for the type: `0..=MAX`
  72
  73 error: `X..=` range patterns are not supported
  74   --> $DIR/recover-range-pats.rs:69:12
  75    |
  76 LL |     if let X..= = 0 {}
  77    |            ^^^^ help: try using the maximum value for the type: `X..=MAX`
  78
  79 error: `X..=` range patterns are not supported
  80   --> $DIR/recover-range-pats.rs:70:12
  81    |
  82 LL |     if let true..= = 0 {}
  83    |            ^^^^^^^ help: try using the maximum value for the type: `true..=MAX`
  84
  85 error: float literals must have an integer part
  86   --> $DIR/recover-range-pats.rs:72:12
  87    |
  88 LL |     if let .0..= = 0 {}
  89    |            ^^ help: must have an integer part: `0.0`
  90
  91 error: `X..=` range patterns are not supported
  92   --> $DIR/recover-range-pats.rs:72:12
  93    |
  94 LL |     if let .0..= = 0 {}
  95    |            ^^^^^ help: try using the maximum value for the type: `0.0..=MAX`
  96
  97 error: `X...` range patterns are not supported
  98   --> $DIR/recover-range-pats.rs:78:12
  99    |
 100 LL |     if let 0... = 0 {}
 101    |            ^^^^ help: try using the maximum value for the type: `0...MAX`
 102
 103 error: `X...` range patterns are not supported
 104   --> $DIR/recover-range-pats.rs:80:12
 105    |
 106 LL |     if let X... = 0 {}
 107    |            ^^^^ help: try using the maximum value for the type: `X...MAX`
 108
 109 error: `X...` range patterns are not supported
 110   --> $DIR/recover-range-pats.rs:82:12
 111    |
 112 LL |     if let true... = 0 {}
 113    |            ^^^^^^^ help: try using the maximum value for the type: `true...MAX`
 114
 115 error: float literals must have an integer part
 116   --> $DIR/recover-range-pats.rs:85:12
 117    |
 118 LL |     if let .0... = 0 {}
 119    |            ^^ help: must have an integer part: `0.0`
 120
 121 error: `X...` range patterns are not supported
 122   --> $DIR/recover-range-pats.rs:85:12
 123    |
 124 LL |     if let .0... = 0 {}
 125    |            ^^^^^ help: try using the maximum value for the type: `0.0...MAX`
 126
 127 error: `..X` range patterns are not supported
 128   --> $DIR/recover-range-pats.rs:92:12
 129    |
 130 LL |     if let ..0 = 0 {}
 131    |            ^^^ help: try using the minimum value for the type: `MIN..0`
 132
 133 error: `..X` range patterns are not supported
 134   --> $DIR/recover-range-pats.rs:93:12
 135    |
 136 LL |     if let ..Y = 0 {}
 137    |            ^^^ help: try using the minimum value for the type: `MIN..Y`
 138
 139 error: `..X` range patterns are not supported
 140   --> $DIR/recover-range-pats.rs:94:12
 141    |
 142 LL |     if let ..true = 0 {}
 143    |            ^^^^^^ help: try using the minimum value for the type: `MIN..true`
 144
 145 error: float literals must have an integer part
 146   --> $DIR/recover-range-pats.rs:96:15
 147    |
 148 LL |     if let .. .0 = 0 {}
 149    |               ^^ help: must have an integer part: `0.0`
 150
 151 error: `..X` range patterns are not supported
 152   --> $DIR/recover-range-pats.rs:96:12
 153    |
 154 LL |     if let .. .0 = 0 {}
 155    |            ^^^^^ help: try using the minimum value for the type: `MIN..0.0`
 156
 157 error: `..=X` range patterns are not supported
 158   --> $DIR/recover-range-pats.rs:102:12
 159    |
 160 LL |     if let ..=3 = 0 {}
 161    |            ^^^^ help: try using the minimum value for the type: `MIN..=3`
 162
 163 error: `..=X` range patterns are not supported
 164   --> $DIR/recover-range-pats.rs:103:12
 165    |
 166 LL |     if let ..=Y = 0 {}
 167    |            ^^^^ help: try using the minimum value for the type: `MIN..=Y`
 168
 169 error: `..=X` range patterns are not supported
 170   --> $DIR/recover-range-pats.rs:104:12
 171    |
 172 LL |     if let ..=true = 0 {}
 173    |            ^^^^^^^ help: try using the minimum value for the type: `MIN..=true`
 174
 175 error: float literals must have an integer part
 176   --> $DIR/recover-range-pats.rs:106:15
 177    |
 178 LL |     if let ..=.0 = 0 {}
 179    |               ^^ help: must have an integer part: `0.0`
 180
 181 error: `..=X` range patterns are not supported
 182   --> $DIR/recover-range-pats.rs:106:12
 183    |
 184 LL |     if let ..=.0 = 0 {}
 185    |            ^^^^^ help: try using the minimum value for the type: `MIN..=0.0`
 186
 187 error: `...X` range patterns are not supported
 188   --> $DIR/recover-range-pats.rs:112:12
 189    |
 190 LL |     if let ...3 = 0 {}
 191    |            ^^^^ help: try using the minimum value for the type: `MIN...3`
 192
 193 error: `...X` range patterns are not supported
 194   --> $DIR/recover-range-pats.rs:114:12
 195    |
 196 LL |     if let ...Y = 0 {}
 197    |            ^^^^ help: try using the minimum value for the type: `MIN...Y`
 198
 199 error: `...X` range patterns are not supported
 200   --> $DIR/recover-range-pats.rs:116:12
 201    |
 202 LL |     if let ...true = 0 {}
 203    |            ^^^^^^^ help: try using the minimum value for the type: `MIN...true`
 204
 205 error: float literals must have an integer part
 206   --> $DIR/recover-range-pats.rs:119:15
 207    |
 208 LL |     if let ....3 = 0 {}
 209    |               ^^ help: must have an integer part: `0.3`
 210
 211 error: `...X` range patterns are not supported
 212   --> $DIR/recover-range-pats.rs:119:12
 213    |
 214 LL |     if let ....3 = 0 {}
 215    |            ^^^^^ help: try using the minimum value for the type: `MIN...0.3`
 216
 217 error: `..X` range patterns are not supported
 218   --> $DIR/recover-range-pats.rs:139:17
 219    |
 220 LL |             let ..$e;
 221    |                 ^^ help: try using the minimum value for the type: `MIN..0`
 222 ...
 223 LL |     mac!(0);
 224    |     -------- in this macro invocation
 225
 226 error: `...X` range patterns are not supported
 227   --> $DIR/recover-range-pats.rs:140:17
 228    |
 229 LL |             let ...$e;
 230    |                 ^^^ help: try using the minimum value for the type: `MIN...0`
 231 ...
 232 LL |     mac!(0);
 233    |     -------- in this macro invocation
 234
 235 error: `..=X` range patterns are not supported
 236   --> $DIR/recover-range-pats.rs:142:17
 237    |
 238 LL |             let ..=$e;
 239    |                 ^^^ help: try using the minimum value for the type: `MIN..=0`
 240 ...
 241 LL |     mac!(0);
 242    |     -------- in this macro invocation
 243
 244 error: `X..` range patterns are not supported
 245   --> $DIR/recover-range-pats.rs:143:19
 246    |
 247 LL |             let $e..;
 248    |                   ^^ help: try using the maximum value for the type: `0..MAX`
 249 ...
 250 LL |     mac!(0);
 251    |     -------- in this macro invocation
 252
 253 error: `X...` range patterns are not supported
 254   --> $DIR/recover-range-pats.rs:144:19
 255    |
 256 LL |             let $e...;
 257    |                   ^^^ help: try using the maximum value for the type: `0...MAX`
 258 ...
 259 LL |     mac!(0);
 260    |     -------- in this macro invocation
 261
 262 error: `X..=` range patterns are not supported
 263   --> $DIR/recover-range-pats.rs:146:19
 264    |
 265 LL |             let $e..=;
 266    |                   ^^^ help: try using the maximum value for the type: `0..=MAX`
 267 ...
 268 LL |     mac!(0);
 269    |     -------- in this macro invocation
 270
 271 error: `...` range patterns are deprecated
 272   --> $DIR/recover-range-pats.rs:41:13
 273    |
 274 LL |     if let 0...3 = 0 {}
 275    |             ^^^ help: use `..=` for an inclusive range
 276    |
 277 note: lint level defined here
 278   --> $DIR/recover-range-pats.rs:7:9
 279    |
 280 LL | #![deny(ellipsis_inclusive_range_patterns)]
 281    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 282
 283 error: `...` range patterns are deprecated
 284   --> $DIR/recover-range-pats.rs:42:13
 285    |
 286 LL |     if let 0...Y = 0 {}
 287    |             ^^^ help: use `..=` for an inclusive range
 288
 289 error: `...` range patterns are deprecated
 290   --> $DIR/recover-range-pats.rs:43:13
 291    |
 292 LL |     if let X...3 = 0 {}
 293    |             ^^^ help: use `..=` for an inclusive range
 294
 295 error: `...` range patterns are deprecated
 296   --> $DIR/recover-range-pats.rs:44:13
 297    |
 298 LL |     if let X...Y = 0 {}
 299    |             ^^^ help: use `..=` for an inclusive range
 300
 301 error: `...` range patterns are deprecated
 302   --> $DIR/recover-range-pats.rs:45:16
 303    |
 304 LL |     if let true...Y = 0 {}
 305    |                ^^^ help: use `..=` for an inclusive range
 306
 307 error: `...` range patterns are deprecated
 308   --> $DIR/recover-range-pats.rs:47:13
 309    |
 310 LL |     if let X...true = 0 {}
 311    |             ^^^ help: use `..=` for an inclusive range
 312
 313 error: `...` range patterns are deprecated
 314   --> $DIR/recover-range-pats.rs:49:14
 315    |
 316 LL |     if let .0...Y = 0 {}
 317    |              ^^^ help: use `..=` for an inclusive range
 318
 319 error: `...` range patterns are deprecated
 320   --> $DIR/recover-range-pats.rs:52:13
 321    |
 322 LL |     if let X... .0 = 0 {}
 323    |             ^^^ help: use `..=` for an inclusive range
 324
 325 error: `...` range patterns are deprecated
 326   --> $DIR/recover-range-pats.rs:78:13
 327    |
 328 LL |     if let 0... = 0 {}
 329    |             ^^^ help: use `..=` for an inclusive range
 330
 331 error: `...` range patterns are deprecated
 332   --> $DIR/recover-range-pats.rs:80:13
 333    |
 334 LL |     if let X... = 0 {}
 335    |             ^^^ help: use `..=` for an inclusive range
 336
 337 error: `...` range patterns are deprecated
 338   --> $DIR/recover-range-pats.rs:82:16
 339    |
 340 LL |     if let true... = 0 {}
 341    |                ^^^ help: use `..=` for an inclusive range
 342
 343 error: `...` range patterns are deprecated
 344   --> $DIR/recover-range-pats.rs:85:14
 345    |
 346 LL |     if let .0... = 0 {}
 347    |              ^^^ help: use `..=` for an inclusive range
 348
 349 error: `...` range patterns are deprecated
 350   --> $DIR/recover-range-pats.rs:112:12
 351    |
 352 LL |     if let ...3 = 0 {}
 353    |            ^^^ help: use `..=` for an inclusive range
 354
 355 error: `...` range patterns are deprecated
 356   --> $DIR/recover-range-pats.rs:114:12
 357    |
 358 LL |     if let ...Y = 0 {}
 359    |            ^^^ help: use `..=` for an inclusive range
 360
 361 error: `...` range patterns are deprecated
 362   --> $DIR/recover-range-pats.rs:116:12
 363    |
 364 LL |     if let ...true = 0 {}
 365    |            ^^^ help: use `..=` for an inclusive range
 366
 367 error: `...` range patterns are deprecated
 368   --> $DIR/recover-range-pats.rs:119:12
 369    |
 370 LL |     if let ....3 = 0 {}
 371    |            ^^^ help: use `..=` for an inclusive range
 372
 373 error: `...` range patterns are deprecated
 374   --> $DIR/recover-range-pats.rs:129:20
 375    |
 376 LL |             let $e1...$e2;
 377    |                    ^^^ help: use `..=` for an inclusive range
 378 ...
 379 LL |     mac2!(0, 1);
 380    |     ------------ in this macro invocation
 381
 382 error: `...` range patterns are deprecated
 383   --> $DIR/recover-range-pats.rs:140:17
 384    |
 385 LL |             let ...$e;
 386    |                 ^^^ help: use `..=` for an inclusive range
 387 ...
 388 LL |     mac!(0);
 389    |     -------- in this macro invocation
 390
 391 error: `...` range patterns are deprecated
 392   --> $DIR/recover-range-pats.rs:144:19
 393    |
 394 LL |             let $e...;
 395    |                   ^^^ help: use `..=` for an inclusive range
 396 ...
 397 LL |     mac!(0);
 398    |     -------- in this macro invocation
 399
 400 error[E0029]: only char and numeric types are allowed in range patterns
 401   --> $DIR/recover-range-pats.rs:19:12
 402    |
 403 LL |     if let true..Y = 0 {}
 404    |            ^^^^  - this is of type `u8`
 405    |            |
 406    |            this is of type `bool` but it should be `char` or numeric
 407
 408 error[E0029]: only char and numeric types are allowed in range patterns
 409   --> $DIR/recover-range-pats.rs:20:15
 410    |
 411 LL |     if let X..true = 0 {}
 412    |            -  ^^^^ this is of type `bool` but it should be `char` or numeric
 413    |            |
 414    |            this is of type `u8`
 415
 416 error[E0308]: mismatched types
 417   --> $DIR/recover-range-pats.rs:21:12
 418    |
 419 LL |     if let .0..Y = 0 {}
 420    |            ^^^^^ expected integer, found floating-point number
 421    |
 422    = note: expected type `{integer}`
 423               found type `{float}`
 424
 425 error[E0308]: mismatched types
 426   --> $DIR/recover-range-pats.rs:23:12
 427    |
 428 LL |     if let X.. .0 = 0 {}
 429    |            ^^^^^^ expected integer, found floating-point number
 430    |
 431    = note: expected type `u8`
 432               found type `{float}`
 433
 434 error[E0029]: only char and numeric types are allowed in range patterns
 435   --> $DIR/recover-range-pats.rs:32:12
 436    |
 437 LL |     if let true..=Y = 0 {}
 438    |            ^^^^   - this is of type `u8`
 439    |            |
 440    |            this is of type `bool` but it should be `char` or numeric
 441
 442 error[E0029]: only char and numeric types are allowed in range patterns
 443   --> $DIR/recover-range-pats.rs:33:16
 444    |
 445 LL |     if let X..=true = 0 {}
 446    |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
 447    |            |
 448    |            this is of type `u8`
 449
 450 error[E0308]: mismatched types
 451   --> $DIR/recover-range-pats.rs:34:12
 452    |
 453 LL |     if let .0..=Y = 0 {}
 454    |            ^^^^^^ expected integer, found floating-point number
 455    |
 456    = note: expected type `{integer}`
 457               found type `{float}`
 458
 459 error[E0308]: mismatched types
 460   --> $DIR/recover-range-pats.rs:36:12
 461    |
 462 LL |     if let X..=.0 = 0 {}
 463    |            ^^^^^^ expected integer, found floating-point number
 464    |
 465    = note: expected type `u8`
 466               found type `{float}`
 467
 468 error[E0029]: only char and numeric types are allowed in range patterns
 469   --> $DIR/recover-range-pats.rs:45:12
 470    |
 471 LL |     if let true...Y = 0 {}
 472    |            ^^^^   - this is of type `u8`
 473    |            |
 474    |            this is of type `bool` but it should be `char` or numeric
 475
 476 error[E0029]: only char and numeric types are allowed in range patterns
 477   --> $DIR/recover-range-pats.rs:47:16
 478    |
 479 LL |     if let X...true = 0 {}
 480    |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
 481    |            |
 482    |            this is of type `u8`
 483
 484 error[E0308]: mismatched types
 485   --> $DIR/recover-range-pats.rs:49:12
 486    |
 487 LL |     if let .0...Y = 0 {}
 488    |            ^^^^^^ expected integer, found floating-point number
 489    |
 490    = note: expected type `{integer}`
 491               found type `{float}`
 492
 493 error[E0308]: mismatched types
 494   --> $DIR/recover-range-pats.rs:52:12
 495    |
 496 LL |     if let X... .0 = 0 {}
 497    |            ^^^^^^^ expected integer, found floating-point number
 498    |
 499    = note: expected type `u8`
 500               found type `{float}`
 501
 502 error[E0029]: only char and numeric types are allowed in range patterns
 503   --> $DIR/recover-range-pats.rs:60:12
 504    |
 505 LL |     if let true.. = 0 {}
 506    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 507
 508 error[E0308]: mismatched types
 509   --> $DIR/recover-range-pats.rs:62:12
 510    |
 511 LL |     if let .0.. = 0 {}
 512    |            ^^^^ expected integer, found floating-point number
 513    |
 514    = note: expected type `{integer}`
 515               found type `{float}`
 516
 517 error[E0029]: only char and numeric types are allowed in range patterns
 518   --> $DIR/recover-range-pats.rs:70:12
 519    |
 520 LL |     if let true..= = 0 {}
 521    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 522
 523 error[E0308]: mismatched types
 524   --> $DIR/recover-range-pats.rs:72:12
 525    |
 526 LL |     if let .0..= = 0 {}
 527    |            ^^^^^ expected integer, found floating-point number
 528    |
 529    = note: expected type `{integer}`
 530               found type `{float}`
 531
 532 error[E0029]: only char and numeric types are allowed in range patterns
 533   --> $DIR/recover-range-pats.rs:82:12
 534    |
 535 LL |     if let true... = 0 {}
 536    |            ^^^^ this is of type `bool` but it should be `char` or numeric
 537
 538 error[E0308]: mismatched types
 539   --> $DIR/recover-range-pats.rs:85:12
 540    |
 541 LL |     if let .0... = 0 {}
 542    |            ^^^^^ expected integer, found floating-point number
 543    |
 544    = note: expected type `{integer}`
 545               found type `{float}`
 546
 547 error[E0029]: only char and numeric types are allowed in range patterns
 548   --> $DIR/recover-range-pats.rs:94:14
 549    |
 550 LL |     if let ..true = 0 {}
 551    |              ^^^^ this is of type `bool` but it should be `char` or numeric
 552
 553 error[E0308]: mismatched types
 554   --> $DIR/recover-range-pats.rs:96:12
 555    |
 556 LL |     if let .. .0 = 0 {}
 557    |            ^^^^^ expected integer, found floating-point number
 558    |
 559    = note: expected type `{integer}`
 560               found type `{float}`
 561
 562 error[E0029]: only char and numeric types are allowed in range patterns
 563   --> $DIR/recover-range-pats.rs:104:15
 564    |
 565 LL |     if let ..=true = 0 {}
 566    |               ^^^^ this is of type `bool` but it should be `char` or numeric
 567
 568 error[E0308]: mismatched types
 569   --> $DIR/recover-range-pats.rs:106:12
 570    |
 571 LL |     if let ..=.0 = 0 {}
 572    |            ^^^^^ expected integer, found floating-point number
 573    |
 574    = note: expected type `{integer}`
 575               found type `{float}`
 576
 577 error[E0029]: only char and numeric types are allowed in range patterns
 578   --> $DIR/recover-range-pats.rs:116:15
 579    |
 580 LL |     if let ...true = 0 {}
 581    |               ^^^^ this is of type `bool` but it should be `char` or numeric
 582
 583 error[E0308]: mismatched types
 584   --> $DIR/recover-range-pats.rs:119:12
 585    |
 586 LL |     if let ....3 = 0 {}
 587    |            ^^^^^ expected integer, found floating-point number
 588    |
 589    = note: expected type `{integer}`
 590               found type `{float}`
 591
 592 error: aborting due to 85 previous errors
 593
 594 Some errors have detailed explanations: E0029, E0308.
 595 For more information about an error, try `rustc --explain E0029`.