647 lines
24 KiB
Plaintext
647 lines
24 KiB
Plaintext
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:59: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:63: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:74: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:80: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:81: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:82: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:84: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:84: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:90: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:91: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:92: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:94: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:94: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:104: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:114: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:120:12
|
|
|
|
|
LL | if let ...3 = 0 {}
|
|
| ^^^ help: use `..=` instead
|
|
|
|
error: range-to patterns with `...` are not allowed
|
|
--> $DIR/recover-range-pats.rs:122:12
|
|
|
|
|
LL | if let ...Y = 0 {}
|
|
| ^^^ help: use `..=` instead
|
|
|
|
error: range-to patterns with `...` are not allowed
|
|
--> $DIR/recover-range-pats.rs:124:12
|
|
|
|
|
LL | if let ...true = 0 {}
|
|
| ^^^ help: use `..=` instead
|
|
|
|
error: float literals must have an integer part
|
|
--> $DIR/recover-range-pats.rs:127: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:127:12
|
|
|
|
|
LL | if let ....3 = 0 {}
|
|
| ^^^ help: use `..=` instead
|
|
|
|
error: range-to patterns with `...` are not allowed
|
|
--> $DIR/recover-range-pats.rs:153:17
|
|
|
|
|
LL | let ...$e;
|
|
| ^^^ help: use `..=` instead
|
|
...
|
|
LL | mac!(0);
|
|
| ------- in this macro invocation
|
|
|
|
|
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
|
|
error[E0586]: inclusive range with no end
|
|
--> $DIR/recover-range-pats.rs:160: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 the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
|
|
error[E0586]: inclusive range with no end
|
|
--> $DIR/recover-range-pats.rs:162: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 the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
|
|
error: `...` range patterns are deprecated
|
|
--> $DIR/recover-range-pats.rs:41:13
|
|
|
|
|
LL | if let 0...3 = 0 {}
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
note: the lint level is 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:44:13
|
|
|
|
|
LL | if let 0...Y = 0 {}
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
|
|
error: `...` range patterns are deprecated
|
|
--> $DIR/recover-range-pats.rs:47:13
|
|
|
|
|
LL | if let X...3 = 0 {}
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
|
|
error: `...` range patterns are deprecated
|
|
--> $DIR/recover-range-pats.rs:50:13
|
|
|
|
|
LL | if let X...Y = 0 {}
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
|
|
error: `...` range patterns are deprecated
|
|
--> $DIR/recover-range-pats.rs:53:16
|
|
|
|
|
LL | if let true...Y = 0 {}
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
|
|
error: `...` range patterns are deprecated
|
|
--> $DIR/recover-range-pats.rs:56:13
|
|
|
|
|
LL | if let X...true = 0 {}
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
|
|
error: `...` range patterns are deprecated
|
|
--> $DIR/recover-range-pats.rs:59:14
|
|
|
|
|
LL | if let .0...Y = 0 {}
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
|
|
error: `...` range patterns are deprecated
|
|
--> $DIR/recover-range-pats.rs:63:13
|
|
|
|
|
LL | if let X... .0 = 0 {}
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
|
|
error: `...` range patterns are deprecated
|
|
--> $DIR/recover-range-pats.rs:138:20
|
|
|
|
|
LL | let $e1...$e2;
|
|
| ^^^ help: use `..=` for an inclusive range
|
|
...
|
|
LL | mac2!(0, 1);
|
|
| ----------- in this macro invocation
|
|
|
|
|
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
|
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
|
|
= note: this error originates in the macro `mac2` (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: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 {}
|
|
| ^^ - - this expression has type `{integer}`
|
|
| | |
|
|
| | this is of type `u8`
|
|
| expected integer, found floating-point number
|
|
|
|
error[E0308]: mismatched types
|
|
--> $DIR/recover-range-pats.rs:23:16
|
|
|
|
|
LL | if let X.. .0 = 0 {}
|
|
| - ^^ - this expression has type `u8`
|
|
| | |
|
|
| | expected `u8`, found floating-point number
|
|
| this is of type `u8`
|
|
|
|
|
= 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 {}
|
|
| ^^^^ - 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 {}
|
|
| ^^ - - this expression has type `{integer}`
|
|
| | |
|
|
| | this is of type `u8`
|
|
| expected integer, found floating-point number
|
|
|
|
error[E0308]: mismatched types
|
|
--> $DIR/recover-range-pats.rs:36:16
|
|
|
|
|
LL | if let X..=.0 = 0 {}
|
|
| - ^^ - this expression has type `u8`
|
|
| | |
|
|
| | expected `u8`, found floating-point number
|
|
| this is of type `u8`
|
|
|
|
|
= note: expected type `u8`
|
|
found type `{float}`
|
|
|
|
error[E0029]: only `char` and numeric types are allowed in range patterns
|
|
--> $DIR/recover-range-pats.rs:53: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:56: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:59:12
|
|
|
|
|
LL | if let .0...Y = 0 {}
|
|
| ^^ - - this expression has type `{integer}`
|
|
| | |
|
|
| | this is of type `u8`
|
|
| expected integer, found floating-point number
|
|
|
|
error[E0308]: mismatched types
|
|
--> $DIR/recover-range-pats.rs:63:17
|
|
|
|
|
LL | if let X... .0 = 0 {}
|
|
| - ^^ - this expression has type `u8`
|
|
| | |
|
|
| | expected `u8`, found floating-point number
|
|
| this is of type `u8`
|
|
|
|
|
= note: expected type `u8`
|
|
found type `{float}`
|
|
|
|
error[E0029]: only `char` and numeric types are allowed in range patterns
|
|
--> $DIR/recover-range-pats.rs:72: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:74:12
|
|
|
|
|
LL | if let .0.. = 0 {}
|
|
| ^^ - this expression has type `{integer}`
|
|
| |
|
|
| 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:84:12
|
|
|
|
|
LL | if let .0..= = 0 {}
|
|
| ^^ - this expression has type `{integer}`
|
|
| |
|
|
| expected integer, found floating-point number
|
|
|
|
error[E0029]: only `char` and numeric types are allowed in range patterns
|
|
--> $DIR/recover-range-pats.rs:92: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:94:12
|
|
|
|
|
LL | if let .0... = 0 {}
|
|
| ^^ - this expression has type `{integer}`
|
|
| |
|
|
| expected integer, found floating-point number
|
|
|
|
error[E0029]: only `char` and numeric types are allowed in range patterns
|
|
--> $DIR/recover-range-pats.rs:102: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:104:15
|
|
|
|
|
LL | if let .. .0 = 0 {}
|
|
| ^^ - this expression has type `{integer}`
|
|
| |
|
|
| expected integer, found floating-point number
|
|
|
|
error[E0029]: only `char` and numeric types are allowed in range patterns
|
|
--> $DIR/recover-range-pats.rs:112: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:114:15
|
|
|
|
|
LL | if let ..=.0 = 0 {}
|
|
| ^^ - this expression has type `{integer}`
|
|
| |
|
|
| expected integer, found floating-point number
|
|
|
|
error[E0029]: only `char` and numeric types are allowed in range patterns
|
|
--> $DIR/recover-range-pats.rs:124: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:127:15
|
|
|
|
|
LL | if let ....3 = 0 {}
|
|
| ^^ - this expression has type `{integer}`
|
|
| |
|
|
| expected integer, found floating-point number
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:136:17
|
|
|
|
|
LL | let $e1..$e2;
|
|
| ^^^^^^^^ patterns `i32::MIN..=-1_i32` and `1_i32..=i32::MAX` not covered
|
|
...
|
|
LL | mac2!(0, 1);
|
|
| ----------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac2` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variants that aren't matched
|
|
|
|
|
LL | if let $e1..$e2; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:138:17
|
|
|
|
|
LL | let $e1...$e2;
|
|
| ^^^^^^^^^ patterns `i32::MIN..=-1_i32` and `2_i32..=i32::MAX` not covered
|
|
...
|
|
LL | mac2!(0, 1);
|
|
| ----------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac2` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variants that aren't matched
|
|
|
|
|
LL | if let $e1...$e2; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:142:17
|
|
|
|
|
LL | let $e1..=$e2;
|
|
| ^^^^^^^^^ patterns `i32::MIN..=-1_i32` and `2_i32..=i32::MAX` not covered
|
|
...
|
|
LL | mac2!(0, 1);
|
|
| ----------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac2` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variants that aren't matched
|
|
|
|
|
LL | if let $e1..=$e2; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:151:17
|
|
|
|
|
LL | let ..$e;
|
|
| ^^^^ pattern `0_i32..=i32::MAX` not covered
|
|
...
|
|
LL | mac!(0);
|
|
| ------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variant that isn't matched
|
|
|
|
|
LL | if let ..$e; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:153:17
|
|
|
|
|
LL | let ...$e;
|
|
| ^^^^^ pattern `1_i32..=i32::MAX` not covered
|
|
...
|
|
LL | mac!(0);
|
|
| ------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variant that isn't matched
|
|
|
|
|
LL | if let ...$e; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:156:17
|
|
|
|
|
LL | let ..=$e;
|
|
| ^^^^^ pattern `1_i32..=i32::MAX` not covered
|
|
...
|
|
LL | mac!(0);
|
|
| ------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variant that isn't matched
|
|
|
|
|
LL | if let ..=$e; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:158:17
|
|
|
|
|
LL | let $e..;
|
|
| ^^^^ pattern `i32::MIN..=-1_i32` not covered
|
|
...
|
|
LL | mac!(0);
|
|
| ------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variant that isn't matched
|
|
|
|
|
LL | if let $e..; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:160:17
|
|
|
|
|
LL | let $e...;
|
|
| ^^^^^ pattern `i32::MIN..=-1_i32` not covered
|
|
...
|
|
LL | mac!(0);
|
|
| ------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variant that isn't matched
|
|
|
|
|
LL | if let $e...; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:162:17
|
|
|
|
|
LL | let $e..=;
|
|
| ^^^^^ pattern `i32::MIN..=-1_i32` not covered
|
|
...
|
|
LL | mac!(0);
|
|
| ------- in this macro invocation
|
|
|
|
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
|
|
= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
|
|
= note: the matched value is of type `i32`
|
|
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
|
|
help: you might want to use `if let` to ignore the variant that isn't matched
|
|
|
|
|
LL | if let $e..=; { todo!() }
|
|
| ++ +++++++++++
|
|
|
|
error: aborting due to 69 previous errors
|
|
|
|
Some errors have detailed explanations: E0005, E0029, E0308, E0586.
|
|
For more information about an error, try `rustc --explain E0005`.
|