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: `...` range patterns are deprecated
 218   --> $DIR/recover-range-pats.rs:41:13
 219    |
 220 LL |     if let 0...3 = 0 {}
 221    |             ^^^ help: use `..=` for an inclusive range
 222    |
 223 note: lint level defined here
 224   --> $DIR/recover-range-pats.rs:7:9
 225    |
 226 LL | #![deny(ellipsis_inclusive_range_patterns)]
 227    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 228
 229 error: `...` range patterns are deprecated
 230   --> $DIR/recover-range-pats.rs:42:13
 231    |
 232 LL |     if let 0...Y = 0 {}
 233    |             ^^^ help: use `..=` for an inclusive range
 234
 235 error: `...` range patterns are deprecated
 236   --> $DIR/recover-range-pats.rs:43:13
 237    |
 238 LL |     if let X...3 = 0 {}
 239    |             ^^^ help: use `..=` for an inclusive range
 240
 241 error: `...` range patterns are deprecated
 242   --> $DIR/recover-range-pats.rs:44:13
 243    |
 244 LL |     if let X...Y = 0 {}
 245    |             ^^^ help: use `..=` for an inclusive range
 246
 247 error: `...` range patterns are deprecated
 248   --> $DIR/recover-range-pats.rs:45:16
 249    |
 250 LL |     if let true...Y = 0 {}
 251    |                ^^^ help: use `..=` for an inclusive range
 252
 253 error: `...` range patterns are deprecated
 254   --> $DIR/recover-range-pats.rs:47:13
 255    |
 256 LL |     if let X...true = 0 {}
 257    |             ^^^ help: use `..=` for an inclusive range
 258
 259 error: `...` range patterns are deprecated
 260   --> $DIR/recover-range-pats.rs:49:14
 261    |
 262 LL |     if let .0...Y = 0 {}
 263    |              ^^^ help: use `..=` for an inclusive range
 264
 265 error: `...` range patterns are deprecated
 266   --> $DIR/recover-range-pats.rs:52:13
 267    |
 268 LL |     if let X... .0 = 0 {}
 269    |             ^^^ help: use `..=` for an inclusive range
 270
 271 error: `...` range patterns are deprecated
 272   --> $DIR/recover-range-pats.rs:78:13
 273    |
 274 LL |     if let 0... = 0 {}
 275    |             ^^^ help: use `..=` for an inclusive range
 276
 277 error: `...` range patterns are deprecated
 278   --> $DIR/recover-range-pats.rs:80:13
 279    |
 280 LL |     if let X... = 0 {}
 281    |             ^^^ help: use `..=` for an inclusive range
 282
 283 error: `...` range patterns are deprecated
 284   --> $DIR/recover-range-pats.rs:82:16
 285    |
 286 LL |     if let true... = 0 {}
 287    |                ^^^ help: use `..=` for an inclusive range
 288
 289 error: `...` range patterns are deprecated
 290   --> $DIR/recover-range-pats.rs:85:14
 291    |
 292 LL |     if let .0... = 0 {}
 293    |              ^^^ help: use `..=` for an inclusive range
 294
 295 error: `...` range patterns are deprecated
 296   --> $DIR/recover-range-pats.rs:112:12
 297    |
 298 LL |     if let ...3 = 0 {}
 299    |            ^^^ help: use `..=` for an inclusive range
 300
 301 error: `...` range patterns are deprecated
 302   --> $DIR/recover-range-pats.rs:114:12
 303    |
 304 LL |     if let ...Y = 0 {}
 305    |            ^^^ help: use `..=` for an inclusive range
 306
 307 error: `...` range patterns are deprecated
 308   --> $DIR/recover-range-pats.rs:116:12
 309    |
 310 LL |     if let ...true = 0 {}
 311    |            ^^^ help: use `..=` for an inclusive range
 312
 313 error: `...` range patterns are deprecated
 314   --> $DIR/recover-range-pats.rs:119:12
 315    |
 316 LL |     if let ....3 = 0 {}
 317    |            ^^^ help: use `..=` for an inclusive range
 318
 319 error[E0029]: only char and numeric types are allowed in range patterns
 320   --> $DIR/recover-range-pats.rs:19:12
 321    |
 322 LL |     if let true..Y = 0 {}
 323    |            ^^^^ ranges require char or numeric types
 324    |
 325    = note: start type: bool
 326    = note: end type: u8
 327
 328 error[E0029]: only char and numeric types are allowed in range patterns
 329   --> $DIR/recover-range-pats.rs:20:15
 330    |
 331 LL |     if let X..true = 0 {}
 332    |               ^^^^ ranges require char or numeric types
 333    |
 334    = note: start type: u8
 335    = note: end type: bool
 336
 337 error[E0308]: mismatched types
 338   --> $DIR/recover-range-pats.rs:21:12
 339    |
 340 LL |     if let .0..Y = 0 {}
 341    |            ^^^^^ expected integer, found floating-point number
 342    |
 343    = note: expected type `{integer}`
 344               found type `{float}`
 345
 346 error[E0308]: mismatched types
 347   --> $DIR/recover-range-pats.rs:23:12
 348    |
 349 LL |     if let X.. .0 = 0 {}
 350    |            ^^^^^^ expected integer, found floating-point number
 351    |
 352    = note: expected type `u8`
 353               found type `{float}`
 354
 355 error[E0029]: only char and numeric types are allowed in range patterns
 356   --> $DIR/recover-range-pats.rs:32:12
 357    |
 358 LL |     if let true..=Y = 0 {}
 359    |            ^^^^ ranges require char or numeric types
 360    |
 361    = note: start type: bool
 362    = note: end type: u8
 363
 364 error[E0029]: only char and numeric types are allowed in range patterns
 365   --> $DIR/recover-range-pats.rs:33:16
 366    |
 367 LL |     if let X..=true = 0 {}
 368    |                ^^^^ ranges require char or numeric types
 369    |
 370    = note: start type: u8
 371    = note: end type: bool
 372
 373 error[E0308]: mismatched types
 374   --> $DIR/recover-range-pats.rs:34:12
 375    |
 376 LL |     if let .0..=Y = 0 {}
 377    |            ^^^^^^ expected integer, found floating-point number
 378    |
 379    = note: expected type `{integer}`
 380               found type `{float}`
 381
 382 error[E0308]: mismatched types
 383   --> $DIR/recover-range-pats.rs:36:12
 384    |
 385 LL |     if let X..=.0 = 0 {}
 386    |            ^^^^^^ expected integer, found floating-point number
 387    |
 388    = note: expected type `u8`
 389               found type `{float}`
 390
 391 error[E0029]: only char and numeric types are allowed in range patterns
 392   --> $DIR/recover-range-pats.rs:45:12
 393    |
 394 LL |     if let true...Y = 0 {}
 395    |            ^^^^ ranges require char or numeric types
 396    |
 397    = note: start type: bool
 398    = note: end type: u8
 399
 400 error[E0029]: only char and numeric types are allowed in range patterns
 401   --> $DIR/recover-range-pats.rs:47:16
 402    |
 403 LL |     if let X...true = 0 {}
 404    |                ^^^^ ranges require char or numeric types
 405    |
 406    = note: start type: u8
 407    = note: end type: bool
 408
 409 error[E0308]: mismatched types
 410   --> $DIR/recover-range-pats.rs:49:12
 411    |
 412 LL |     if let .0...Y = 0 {}
 413    |            ^^^^^^ expected integer, found floating-point number
 414    |
 415    = note: expected type `{integer}`
 416               found type `{float}`
 417
 418 error[E0308]: mismatched types
 419   --> $DIR/recover-range-pats.rs:52:12
 420    |
 421 LL |     if let X... .0 = 0 {}
 422    |            ^^^^^^^ expected integer, found floating-point number
 423    |
 424    = note: expected type `u8`
 425               found type `{float}`
 426
 427 error[E0029]: only char and numeric types are allowed in range patterns
 428   --> $DIR/recover-range-pats.rs:60:12
 429    |
 430 LL |     if let true.. = 0 {}
 431    |            ^^^^ ranges require char or numeric types
 432    |
 433    = note: start type: bool
 434    = note: end type: [type error]
 435
 436 error[E0308]: mismatched types
 437   --> $DIR/recover-range-pats.rs:62:12
 438    |
 439 LL |     if let .0.. = 0 {}
 440    |            ^^^^ expected integer, found floating-point number
 441    |
 442    = note: expected type `{integer}`
 443               found type `{float}`
 444
 445 error[E0029]: only char and numeric types are allowed in range patterns
 446   --> $DIR/recover-range-pats.rs:70:12
 447    |
 448 LL |     if let true..= = 0 {}
 449    |            ^^^^ ranges require char or numeric types
 450    |
 451    = note: start type: bool
 452    = note: end type: [type error]
 453
 454 error[E0308]: mismatched types
 455   --> $DIR/recover-range-pats.rs:72:12
 456    |
 457 LL |     if let .0..= = 0 {}
 458    |            ^^^^^ expected integer, found floating-point number
 459    |
 460    = note: expected type `{integer}`
 461               found type `{float}`
 462
 463 error[E0029]: only char and numeric types are allowed in range patterns
 464   --> $DIR/recover-range-pats.rs:82:12
 465    |
 466 LL |     if let true... = 0 {}
 467    |            ^^^^ ranges require char or numeric types
 468    |
 469    = note: start type: bool
 470    = note: end type: [type error]
 471
 472 error[E0308]: mismatched types
 473   --> $DIR/recover-range-pats.rs:85:12
 474    |
 475 LL |     if let .0... = 0 {}
 476    |            ^^^^^ expected integer, found floating-point number
 477    |
 478    = note: expected type `{integer}`
 479               found type `{float}`
 480
 481 error[E0029]: only char and numeric types are allowed in range patterns
 482   --> $DIR/recover-range-pats.rs:94:14
 483    |
 484 LL |     if let ..true = 0 {}
 485    |              ^^^^ ranges require char or numeric types
 486    |
 487    = note: start type: [type error]
 488    = note: end type: bool
 489
 490 error[E0308]: mismatched types
 491   --> $DIR/recover-range-pats.rs:96:12
 492    |
 493 LL |     if let .. .0 = 0 {}
 494    |            ^^^^^ expected integer, found floating-point number
 495    |
 496    = note: expected type `{integer}`
 497               found type `{float}`
 498
 499 error[E0029]: only char and numeric types are allowed in range patterns
 500   --> $DIR/recover-range-pats.rs:104:15
 501    |
 502 LL |     if let ..=true = 0 {}
 503    |               ^^^^ ranges require char or numeric types
 504    |
 505    = note: start type: [type error]
 506    = note: end type: bool
 507
 508 error[E0308]: mismatched types
 509   --> $DIR/recover-range-pats.rs:106: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:116:15
 519    |
 520 LL |     if let ...true = 0 {}
 521    |               ^^^^ ranges require char or numeric types
 522    |
 523    = note: start type: [type error]
 524    = note: end type: bool
 525
 526 error[E0308]: mismatched types
 527   --> $DIR/recover-range-pats.rs:119:12
 528    |
 529 LL |     if let ....3 = 0 {}
 530    |            ^^^^^ expected integer, found floating-point number
 531    |
 532    = note: expected type `{integer}`
 533               found type `{float}`
 534
 535 error: aborting due to 76 previous errors
 536
 537 Some errors have detailed explanations: E0029, E0308.
 538 For more information about an error, try `rustc --explain E0029`.