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

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:21:12
   |
LL |     if let .0..Y = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:23:16
   |
LL |     if let X.. .0 = 0 {}
   |                ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:34:12
   |
LL |     if let .0..=Y = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:36:16
   |
LL |     if let X..=.0 = 0 {}
   |                ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:49:12
   |
LL |     if let .0...Y = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:52:17
   |
LL |     if let X... .0 = 0 {}
   |                 ^^ help: must have an integer part: `0.0`

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:58:12
   |
LL |     if let 0.. = 0 {}
   |            ^^^ help: try using the maximum value for the type: `0..MAX`

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:59:12
   |
LL |     if let X.. = 0 {}
   |            ^^^ help: try using the maximum value for the type: `X..MAX`

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:60:12
   |
LL |     if let true.. = 0 {}
   |            ^^^^^^ help: try using the maximum value for the type: `true..MAX`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:62:12
   |
LL |     if let .0.. = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:62:12
   |
LL |     if let .0.. = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `0.0..MAX`

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:68:12
   |
LL |     if let 0..= = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `0..=MAX`

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:69:12
   |
LL |     if let X..= = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `X..=MAX`

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:70:12
   |
LL |     if let true..= = 0 {}
   |            ^^^^^^^ help: try using the maximum value for the type: `true..=MAX`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:72:12
   |
LL |     if let .0..= = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:72:12
   |
LL |     if let .0..= = 0 {}
   |            ^^^^^ help: try using the maximum value for the type: `0.0..=MAX`

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:78:12
   |
LL |     if let 0... = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `0...MAX`

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:80:12
   |
LL |     if let X... = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `X...MAX`

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:82:12
   |
LL |     if let true... = 0 {}
   |            ^^^^^^^ help: try using the maximum value for the type: `true...MAX`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:85:12
   |
LL |     if let .0... = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:85:12
   |
LL |     if let .0... = 0 {}
   |            ^^^^^ help: try using the maximum value for the type: `0.0...MAX`

error: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:92:12
   |
LL |     if let ..0 = 0 {}
   |            ^^^ help: try using the minimum value for the type: `MIN..0`

error: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:93:12
   |
LL |     if let ..Y = 0 {}
   |            ^^^ help: try using the minimum value for the type: `MIN..Y`

error: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:94:12
   |
LL |     if let ..true = 0 {}
   |            ^^^^^^ help: try using the minimum value for the type: `MIN..true`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:96:15
   |
LL |     if let .. .0 = 0 {}
   |               ^^ help: must have an integer part: `0.0`

error: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:96:12
   |
LL |     if let .. .0 = 0 {}
   |            ^^^^^ help: try using the minimum value for the type: `MIN..0.0`

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:102:12
   |
LL |     if let ..=3 = 0 {}
   |            ^^^^ help: try using the minimum value for the type: `MIN..=3`

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:103:12
   |
LL |     if let ..=Y = 0 {}
   |            ^^^^ help: try using the minimum value for the type: `MIN..=Y`

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:104:12
   |
LL |     if let ..=true = 0 {}
   |            ^^^^^^^ help: try using the minimum value for the type: `MIN..=true`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:106:15
   |
LL |     if let ..=.0 = 0 {}
   |               ^^ help: must have an integer part: `0.0`

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:106:12
   |
LL |     if let ..=.0 = 0 {}
   |            ^^^^^ help: try using the minimum value for the type: `MIN..=0.0`

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:112:12
   |
LL |     if let ...3 = 0 {}
   |            ^^^^ help: try using the minimum value for the type: `MIN...3`

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:114:12
   |
LL |     if let ...Y = 0 {}
   |            ^^^^ help: try using the minimum value for the type: `MIN...Y`

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:116:12
   |
LL |     if let ...true = 0 {}
   |            ^^^^^^^ help: try using the minimum value for the type: `MIN...true`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:119:15
   |
LL |     if let ....3 = 0 {}
   |               ^^ help: must have an integer part: `0.3`

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:119:12
   |
LL |     if let ....3 = 0 {}
   |            ^^^^^ help: try using the minimum value for the type: `MIN...0.3`

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:41:13
   |
LL |     if let 0...3 = 0 {}
   |             ^^^ help: use `..=` for an inclusive range
   |
note: lint level defined here
  --> $DIR/recover-range-pats.rs:7:9
   |
LL | #![deny(ellipsis_inclusive_range_patterns)]
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:42:13
   |
LL |     if let 0...Y = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:43:13
   |
LL |     if let X...3 = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:44:13
   |
LL |     if let X...Y = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:45:16
   |
LL |     if let true...Y = 0 {}
   |                ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:47:13
   |
LL |     if let X...true = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:49:14
   |
LL |     if let .0...Y = 0 {}
   |              ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:52:13
   |
LL |     if let X... .0 = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:78:13
   |
LL |     if let 0... = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:80:13
   |
LL |     if let X... = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:82:16
   |
LL |     if let true... = 0 {}
   |                ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:85:14
   |
LL |     if let .0... = 0 {}
   |              ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:112:12
   |
LL |     if let ...3 = 0 {}
   |            ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:114:12
   |
LL |     if let ...Y = 0 {}
   |            ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:116:12
   |
LL |     if let ...true = 0 {}
   |            ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:119:12
   |
LL |     if let ....3 = 0 {}
   |            ^^^ help: use `..=` for an inclusive range

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:19:12
   |
LL |     if let true..Y = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:20:15
   |
LL |     if let X..true = 0 {}
   |               ^^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:21:12
   |
LL |     if let .0..Y = 0 {}
   |            ^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:23:12
   |
LL |     if let X.. .0 = 0 {}
   |            ^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `u8`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:32:12
   |
LL |     if let true..=Y = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:33:16
   |
LL |     if let X..=true = 0 {}
   |                ^^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:34:12
   |
LL |     if let .0..=Y = 0 {}
   |            ^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:36:12
   |
LL |     if let X..=.0 = 0 {}
   |            ^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `u8`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:45:12
   |
LL |     if let true...Y = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:47:16
   |
LL |     if let X...true = 0 {}
   |                ^^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:49:12
   |
LL |     if let .0...Y = 0 {}
   |            ^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:52:12
   |
LL |     if let X... .0 = 0 {}
   |            ^^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `u8`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:60:12
   |
LL |     if let true.. = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: [type error]

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:62:12
   |
LL |     if let .0.. = 0 {}
   |            ^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:70:12
   |
LL |     if let true..= = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: [type error]

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:72:12
   |
LL |     if let .0..= = 0 {}
   |            ^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:82:12
   |
LL |     if let true... = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: [type error]

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:85:12
   |
LL |     if let .0... = 0 {}
   |            ^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:94:14
   |
LL |     if let ..true = 0 {}
   |              ^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:96:12
   |
LL |     if let .. .0 = 0 {}
   |            ^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:104:15
   |
LL |     if let ..=true = 0 {}
   |               ^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:106:12
   |
LL |     if let ..=.0 = 0 {}
   |            ^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:116:15
   |
LL |     if let ...true = 0 {}
   |               ^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:119:12
   |
LL |     if let ....3 = 0 {}
   |            ^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error: aborting due to 76 previous errors

Some errors have detailed explanations: E0029, E0308.
For more information about an error, try `rustc --explain E0029`.