692bc344d5
Go over all structured parser suggestions and make them verbose style. When suggesting to add or remove delimiters, turn them into multiple suggestion parts.
736 lines
23 KiB
Plaintext
736 lines
23 KiB
Plaintext
error: float literals must have an integer part
|
|
--> $DIR/recover-range-pats.rs:20: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:22: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:33: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:35: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:58: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:62: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:73: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:79: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:80: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:81: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:83: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:83: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:89: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:90: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:91: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:93: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:93: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:103: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:113: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:119:12
|
|
|
|
|
LL | if let ...3 = 0 {}
|
|
| ^^^
|
|
|
|
|
help: use `..=` instead
|
|
|
|
|
LL | if let ..=3 = 0 {}
|
|
| ~~~
|
|
|
|
error: range-to patterns with `...` are not allowed
|
|
--> $DIR/recover-range-pats.rs:121:12
|
|
|
|
|
LL | if let ...Y = 0 {}
|
|
| ^^^
|
|
|
|
|
help: use `..=` instead
|
|
|
|
|
LL | if let ..=Y = 0 {}
|
|
| ~~~
|
|
|
|
error: range-to patterns with `...` are not allowed
|
|
--> $DIR/recover-range-pats.rs:123:12
|
|
|
|
|
LL | if let ...true = 0 {}
|
|
| ^^^
|
|
|
|
|
help: use `..=` instead
|
|
|
|
|
LL | if let ..=true = 0 {}
|
|
| ~~~
|
|
|
|
error: float literals must have an integer part
|
|
--> $DIR/recover-range-pats.rs:126: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:126:12
|
|
|
|
|
LL | if let ....3 = 0 {}
|
|
| ^^^
|
|
|
|
|
help: use `..=` instead
|
|
|
|
|
LL | if let ..=.3 = 0 {}
|
|
| ~~~
|
|
|
|
error: range-to patterns with `...` are not allowed
|
|
--> $DIR/recover-range-pats.rs:152: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;
|
|
| ~~~
|
|
|
|
error[E0586]: inclusive range with no end
|
|
--> $DIR/recover-range-pats.rs:159: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:161: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:40: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:6: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
|
|
|
|
|
= 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:46: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:49: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:52: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:55: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:58: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:62: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:137: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:18: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:19: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:20: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:22: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:31: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:32: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:33: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:35: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:52: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:55: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:58: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:62: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: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 {}
|
|
| ^^ - 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: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 {}
|
|
| ^^ - 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:91: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:93: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:101: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:103: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:111: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:113: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:123: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:126: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:135: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)
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:137: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)
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:141: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)
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:150: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)
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:152: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)
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:155: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)
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:157: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)
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:159: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)
|
|
|
|
error[E0005]: refutable pattern in local binding
|
|
--> $DIR/recover-range-pats.rs:161: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)
|
|
|
|
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`.
|