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: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:139:17
   |
LL |             let ..$e;
   |                 ^^ help: try using the minimum value for the type: `MIN..0`
...
LL |     mac!(0);
   |     -------- in this macro invocation

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:140:17
   |
LL |             let ...$e;
   |                 ^^^ help: try using the minimum value for the type: `MIN...0`
...
LL |     mac!(0);
   |     -------- in this macro invocation

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:142:17
   |
LL |             let ..=$e;
   |                 ^^^ help: try using the minimum value for the type: `MIN..=0`
...
LL |     mac!(0);
   |     -------- in this macro invocation

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:143:19
   |
LL |             let $e..;
   |                   ^^ help: try using the maximum value for the type: `0..MAX`
...
LL |     mac!(0);
   |     -------- in this macro invocation

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:144:19
   |
LL |             let $e...;
   |                   ^^^ help: try using the maximum value for the type: `0...MAX`
...
LL |     mac!(0);
   |     -------- in this macro invocation

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:146:19
   |
LL |             let $e..=;
   |                   ^^^ help: try using the maximum value for the type: `0..=MAX`
...
LL |     mac!(0);
   |     -------- in this macro invocation

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: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:129:20
   |
LL |             let $e1...$e2;
   |                    ^^^ help: use `..=` for an inclusive range
...
LL |     mac2!(0, 1);
   |     ------------ in this macro invocation

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:140:17
   |
LL |             let ...$e;
   |                 ^^^ help: use `..=` for an inclusive range
...
LL |     mac!(0);
   |     -------- in this macro invocation

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:144:19
   |
LL |             let $e...;
   |                   ^^^ help: use `..=` for an inclusive range
...
LL |     mac!(0);
   |     -------- in this macro invocation

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 {}
   |            ^^^^  - this is of type `u8`
   |            |
   |            this is of type `bool` but it should be `char` or numeric

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 {}
   |            -  ^^^^ this is of type `bool` but it should be `char` or numeric
   |            |
   |            this is of type `u8`

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

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

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 {}
   |            ^^^^   - this is of type `u8`
   |            |
   |            this is of type `bool` but it should be `char` or numeric

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 {}
   |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
   |            |
   |            this is of type `u8`

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

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

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 {}
   |            ^^^^   - this is of type `u8`
   |            |
   |            this is of type `bool` but it should be `char` or numeric

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 {}
   |            -   ^^^^ this is of type `bool` but it should be `char` or numeric
   |            |
   |            this is of type `u8`

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

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

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:60:12
   |
LL |     if let true.. = 0 {}
   |            ^^^^ this is of type `bool` but it should be `char` or numeric

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

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:70:12
   |
LL |     if let true..= = 0 {}
   |            ^^^^ this is of type `bool` but it should be `char` or numeric

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

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:82:12
   |
LL |     if let true... = 0 {}
   |            ^^^^ this is of type `bool` but it should be `char` or numeric

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

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:94:14
   |
LL |     if let ..true = 0 {}
   |              ^^^^ this is of type `bool` but it should be `char` or numeric

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

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:104:15
   |
LL |     if let ..=true = 0 {}
   |               ^^^^ this is of type `bool` but it should be `char` or numeric

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

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:116:15
   |
LL |     if let ...true = 0 {}
   |               ^^^^ this is of type `bool` but it should be `char` or numeric

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

error: aborting due to 85 previous errors

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