| 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 |
| | |
| LL | if let 0.0..Y = 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 |
| | |
| LL | if let X.. 0.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 |
| | |
| LL | if let 0.0..=Y = 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 |
| | |
| LL | if let X..=0.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 |
| | |
| LL | if let 0.0...Y = 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 |
| | |
| LL | if let X... 0.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 |
| | |
| LL | if let 0.0.. = 0 {} |
| | + |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:80:13 |
| | |
| LL | if let 0..= = 0 {} |
| | ^^^ |
| | |
| = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) |
| help: use `..` instead |
| | |
| LL - if let 0..= = 0 {} |
| LL + if let 0.. = 0 {} |
| | |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:81:13 |
| | |
| LL | if let X..= = 0 {} |
| | ^^^ |
| | |
| = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) |
| help: use `..` instead |
| | |
| LL - if let X..= = 0 {} |
| LL + if let X.. = 0 {} |
| | |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:82:16 |
| | |
| LL | if let true..= = 0 {} |
| | ^^^ |
| | |
| = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) |
| help: use `..` instead |
| | |
| LL - if let true..= = 0 {} |
| LL + if let true.. = 0 {} |
| | |
| |
| 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 |
| | |
| LL | if let 0.0..= = 0 {} |
| | + |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:84:14 |
| | |
| LL | if let .0..= = 0 {} |
| | ^^^ |
| | |
| = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) |
| help: use `..` instead |
| | |
| LL - if let .0..= = 0 {} |
| LL + if let .0.. = 0 {} |
| | |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:90:13 |
| | |
| LL | if let 0... = 0 {} |
| | ^^^ |
| | |
| = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) |
| help: use `..` instead |
| | |
| LL - if let 0... = 0 {} |
| LL + if let 0.. = 0 {} |
| | |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:91:13 |
| | |
| LL | if let X... = 0 {} |
| | ^^^ |
| | |
| = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) |
| help: use `..` instead |
| | |
| LL - if let X... = 0 {} |
| LL + if let X.. = 0 {} |
| | |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:92:16 |
| | |
| LL | if let true... = 0 {} |
| | ^^^ |
| | |
| = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) |
| help: use `..` instead |
| | |
| LL - if let true... = 0 {} |
| LL + if let true.. = 0 {} |
| | |
| |
| 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 |
| | |
| LL | if let 0.0... = 0 {} |
| | + |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:94:14 |
| | |
| LL | if let .0... = 0 {} |
| | ^^^ |
| | |
| = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) |
| help: use `..` instead |
| | |
| LL - if let .0... = 0 {} |
| LL + if let .0.. = 0 {} |
| | |
| |
| 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 |
| | |
| LL | if let .. 0.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 |
| | |
| LL | if let ..=0.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 |
| | |
| LL - if let ...3 = 0 {} |
| LL + if let ..=3 = 0 {} |
| | |
| |
| error: range-to patterns with `...` are not allowed |
| --> $DIR/recover-range-pats.rs:122:12 |
| | |
| LL | if let ...Y = 0 {} |
| | ^^^ |
| | |
| help: use `..=` instead |
| | |
| LL - if let ...Y = 0 {} |
| LL + if let ..=Y = 0 {} |
| | |
| |
| error: range-to patterns with `...` are not allowed |
| --> $DIR/recover-range-pats.rs:124:12 |
| | |
| LL | if let ...true = 0 {} |
| | ^^^ |
| | |
| help: use `..=` instead |
| | |
| LL - if let ...true = 0 {} |
| LL + if let ..=true = 0 {} |
| | |
| |
| 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 |
| | |
| LL | if let ...0.3 = 0 {} |
| | + |
| |
| error: range-to patterns with `...` are not allowed |
| --> $DIR/recover-range-pats.rs:127:12 |
| | |
| LL | if let ....3 = 0 {} |
| | ^^^ |
| | |
| help: use `..=` instead |
| | |
| LL - if let ....3 = 0 {} |
| LL + if let ..=.3 = 0 {} |
| | |
| |
| error: range-to patterns with `...` are not allowed |
| --> $DIR/recover-range-pats.rs:153:17 |
| | |
| LL | let ...$e; |
| | ^^^ |
| ... |
| 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) |
| help: use `..=` instead |
| | |
| LL - let ...$e; |
| LL + let ..=$e; |
| | |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:160:19 |
| | |
| LL | let $e...; |
| | ^^^ |
| ... |
| 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) |
| help: use `..` instead |
| | |
| LL - let $e...; |
| LL + let $e..; |
| | |
| |
| error[E0586]: inclusive range with no end |
| --> $DIR/recover-range-pats.rs:162:19 |
| | |
| LL | let $e..=; |
| | ^^^ |
| ... |
| 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) |
| help: use `..` instead |
| | |
| LL - let $e..=; |
| LL + let $e..; |
| | |
| |
| 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/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/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/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/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/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/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/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/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/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` |
| |
| 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` |
| |
| 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` |
| |
| 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/ch19-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) |
| |
| 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/ch19-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) |
| |
| 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/ch19-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) |
| |
| 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/ch19-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) |
| |
| 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/ch19-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) |
| |
| 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/ch19-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) |
| |
| 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/ch19-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) |
| |
| 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/ch19-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) |
| |
| 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/ch19-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) |
| |
| 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`. |
