src/test/ui/parser/recover-range-pats.stderr - third_party/rust - Git at Google

 error: float literals must have an integer part
   --> $DIR/recover-range-pats.rs:22: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:24: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:35: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:37: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:50: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:53:17
    |
 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:63:12
    |
 LL |     if let .0.. = 0 {}
    |            ^^ help: must have an integer part: `0.0`

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:69:13
    |
 LL |     if let 0..= = 0 {}
    |             ^^^ help: use `..` instead
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:70:13
    |
 LL |     if let X..= = 0 {}
    |             ^^^ help: use `..` instead
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:71:16
    |
 LL |     if let true..= = 0 {}
    |                ^^^ help: use `..` instead
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

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

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:73:14
    |
 LL |     if let .0..= = 0 {}
    |              ^^^ help: use `..` instead
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:79:13
    |
 LL |     if let 0... = 0 {}
    |             ^^^ help: use `..` instead
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:80:13
    |
 LL |     if let X... = 0 {}
    |             ^^^ help: use `..` instead
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:81:16
    |
 LL |     if let true... = 0 {}
    |                ^^^ help: use `..` instead
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

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

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:83:14
    |
 LL |     if let .0... = 0 {}
    |              ^^^ help: use `..` instead
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

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

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

 error: range-to patterns with `...` are not allowed
   --> $DIR/recover-range-pats.rs:109:12
    |
 LL |     if let ...3 = 0 {}
    |            ^^^ help: use `..=` instead

 error: range-to patterns with `...` are not allowed
   --> $DIR/recover-range-pats.rs:111:12
    |
 LL |     if let ...Y = 0 {}
    |            ^^^ help: use `..=` instead

 error: range-to patterns with `...` are not allowed
   --> $DIR/recover-range-pats.rs:113:12
    |
 LL |     if let ...true = 0 {}
    |            ^^^ help: use `..=` instead

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

 error: range-to patterns with `...` are not allowed
   --> $DIR/recover-range-pats.rs:116:12
    |
 LL |     if let ....3 = 0 {}
    |            ^^^ help: use `..=` instead

 error: range-to patterns with `...` are not allowed
   --> $DIR/recover-range-pats.rs:137:17
    |
 LL |             let ...$e;
    |                 ^^^ help: use `..=` instead
 ...
 LL |     mac!(0);
    |     -------- in this macro invocation
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:141:19
    |
 LL |             let $e...;
    |                   ^^^ help: use `..` instead
 ...
 LL |     mac!(0);
    |     -------- in this macro invocation
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

 error[E0586]: inclusive range with no end
   --> $DIR/recover-range-pats.rs:142:19
    |
 LL |             let $e..=;
    |                   ^^^ help: use `..` instead
 ...
 LL |     mac!(0);
    |     -------- in this macro invocation
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

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

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

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

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

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

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

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

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

 error: `...` range patterns are deprecated
   --> $DIR/recover-range-pats.rs:126:20
    |
 LL |             let $e1...$e2;
    |                    ^^^ help: use `..=` for an inclusive range
 ...
 LL |     mac2!(0, 1);
    |     ------------ in this macro invocation
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

 error[E0029]: only `char` and numeric types are allowed in range patterns
   --> $DIR/recover-range-pats.rs:20: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:21: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:22:12
    |
 LL |     if let .0..Y = 0 {}
    |            ^^  - this is of type `u8`
    |            |
    |            expected integer, found floating-point number

 error[E0308]: mismatched types
   --> $DIR/recover-range-pats.rs:24:16
    |
 LL |     if let X.. .0 = 0 {}
    |            -   ^^   - this expression has type `u8`
    |            |   |
    |            |   expected integer, found floating-point number
    |            this is of type `u8`

 error[E0029]: only `char` and numeric types are allowed in range patterns
   --> $DIR/recover-range-pats.rs:33: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:34: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:35:12
    |
 LL |     if let .0..=Y = 0 {}
    |            ^^   - this is of type `u8`
    |            |
    |            expected integer, found floating-point number

 error[E0308]: mismatched types
   --> $DIR/recover-range-pats.rs:37:16
    |
 LL |     if let X..=.0 = 0 {}
    |            -   ^^   - this expression has type `u8`
    |            |   |
    |            |   expected integer, found floating-point number
    |            this is of type `u8`

 error[E0029]: only `char` and numeric types are allowed in range patterns
   --> $DIR/recover-range-pats.rs:46: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:48: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:50:12
    |
 LL |     if let .0...Y = 0 {}
    |            ^^   - this is of type `u8`
    |            |
    |            expected integer, found floating-point number

 error[E0308]: mismatched types
   --> $DIR/recover-range-pats.rs:53:17
    |
 LL |     if let X... .0 = 0 {}
    |            -    ^^   - this expression has type `u8`
    |            |    |
    |            |    expected integer, found floating-point number
    |            this is of type `u8`

 error[E0029]: only `char` and numeric types are allowed in range patterns
   --> $DIR/recover-range-pats.rs:61: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:63: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:71: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:73: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:81: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:83: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:91: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:93:15
    |
 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:101: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:103:15
    |
 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:113: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:116:15
    |
 LL |     if let ....3 = 0 {}
    |               ^^ expected integer, found floating-point number

 error: aborting due to 60 previous errors

 Some errors have detailed explanations: E0029, E0308, E0586.
 For more information about an error, try `rustc --explain E0029`.
	error: float literals must have an integer part
	--> $DIR/recover-range-pats.rs:22: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:24: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:35: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:37: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:50: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:53:17
	\|
	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:63:12
	\|
	LL \| if let .0.. = 0 {}
	\| ^^ help: must have an integer part: `0.0`

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:69:13
	\|
	LL \| if let 0..= = 0 {}
	\| ^^^ help: use `..` instead
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:70:13
	\|
	LL \| if let X..= = 0 {}
	\| ^^^ help: use `..` instead
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:71:16
	\|
	LL \| if let true..= = 0 {}
	\| ^^^ help: use `..` instead
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

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

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:73:14
	\|
	LL \| if let .0..= = 0 {}
	\| ^^^ help: use `..` instead
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:79:13
	\|
	LL \| if let 0... = 0 {}
	\| ^^^ help: use `..` instead
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:80:13
	\|
	LL \| if let X... = 0 {}
	\| ^^^ help: use `..` instead
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:81:16
	\|
	LL \| if let true... = 0 {}
	\| ^^^ help: use `..` instead
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

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

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:83:14
	\|
	LL \| if let .0... = 0 {}
	\| ^^^ help: use `..` instead
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)

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

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

	error: range-to patterns with `...` are not allowed
	--> $DIR/recover-range-pats.rs:109:12
	\|
	LL \| if let ...3 = 0 {}
	\| ^^^ help: use `..=` instead

	error: range-to patterns with `...` are not allowed
	--> $DIR/recover-range-pats.rs:111:12
	\|
	LL \| if let ...Y = 0 {}
	\| ^^^ help: use `..=` instead

	error: range-to patterns with `...` are not allowed
	--> $DIR/recover-range-pats.rs:113:12
	\|
	LL \| if let ...true = 0 {}
	\| ^^^ help: use `..=` instead

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

	error: range-to patterns with `...` are not allowed
	--> $DIR/recover-range-pats.rs:116:12
	\|
	LL \| if let ....3 = 0 {}
	\| ^^^ help: use `..=` instead

	error: range-to patterns with `...` are not allowed
	--> $DIR/recover-range-pats.rs:137:17
	\|
	LL \| let ...$e;
	\| ^^^ help: use `..=` instead
	...
	LL \| mac!(0);
	\| -------- in this macro invocation
	\|
	= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:141:19
	\|
	LL \| let $e...;
	\| ^^^ help: use `..` instead
	...
	LL \| mac!(0);
	\| -------- in this macro invocation
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
	= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

	error[E0586]: inclusive range with no end
	--> $DIR/recover-range-pats.rs:142:19
	\|
	LL \| let $e..=;
	\| ^^^ help: use `..` instead
	...
	LL \| mac!(0);
	\| -------- in this macro invocation
	\|
	= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
	= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

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

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

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

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

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

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

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

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

	error: `...` range patterns are deprecated
	--> $DIR/recover-range-pats.rs:126:20
	\|
	LL \| let $e1...$e2;
	\| ^^^ help: use `..=` for an inclusive range
	...
	LL \| mac2!(0, 1);
	\| ------------ in this macro invocation
	\|
	= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

	error[E0029]: only `char` and numeric types are allowed in range patterns
	--> $DIR/recover-range-pats.rs:20: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:21: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:22:12
	\|
	LL \| if let .0..Y = 0 {}
	\| ^^ - this is of type `u8`
	\| \|
	\| expected integer, found floating-point number

	error[E0308]: mismatched types
	--> $DIR/recover-range-pats.rs:24:16
	\|
	LL \| if let X.. .0 = 0 {}
	\| - ^^ - this expression has type `u8`
	\| \| \|
	\| \| expected integer, found floating-point number
	\| this is of type `u8`

	error[E0029]: only `char` and numeric types are allowed in range patterns
	--> $DIR/recover-range-pats.rs:33: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:34: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:35:12
	\|
	LL \| if let .0..=Y = 0 {}
	\| ^^ - this is of type `u8`
	\| \|
	\| expected integer, found floating-point number

	error[E0308]: mismatched types
	--> $DIR/recover-range-pats.rs:37:16
	\|
	LL \| if let X..=.0 = 0 {}
	\| - ^^ - this expression has type `u8`
	\| \| \|
	\| \| expected integer, found floating-point number
	\| this is of type `u8`

	error[E0029]: only `char` and numeric types are allowed in range patterns
	--> $DIR/recover-range-pats.rs:46: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:48: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:50:12
	\|
	LL \| if let .0...Y = 0 {}
	\| ^^ - this is of type `u8`
	\| \|
	\| expected integer, found floating-point number

	error[E0308]: mismatched types
	--> $DIR/recover-range-pats.rs:53:17
	\|
	LL \| if let X... .0 = 0 {}
	\| - ^^ - this expression has type `u8`
	\| \| \|
	\| \| expected integer, found floating-point number
	\| this is of type `u8`

	error[E0029]: only `char` and numeric types are allowed in range patterns
	--> $DIR/recover-range-pats.rs:61: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:63: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:71: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:73: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:81: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:83: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:91: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:93:15
	\|
	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:101: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:103:15
	\|
	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:113: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:116:15
	\|
	LL \| if let ....3 = 0 {}
	\| ^^ expected integer, found floating-point number

	error: aborting due to 60 previous errors

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