rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
51b51b51d7931da85280382a81c4dd80c73ca754
rust/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.classic2024.stderr

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

134 lines
3.6 KiB
Plaintext
Raw Normal View History

reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
error[E0308]: mismatched types
add test revisions for old-edition behavior of feature gates This also adds `#[cfg]` attributes to tests for bindings' types, to make it visually clearer which revisions type successfully.
2025-01-22 23:59:03 -08:00
--> $DIR/pattern-errors.rs:14:17
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
|
LL | if let Some(&mut x) = &Some(&mut 0) {
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - if let Some(&mut x) = &Some(&mut 0) {
LL + if let Some(&x) = &Some(&mut 0) {
|
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
error[E0308]: mismatched types
add test revisions for old-edition behavior of feature gates This also adds `#[cfg]` attributes to tests for bindings' types, to make it visually clearer which revisions type successfully.
2025-01-22 23:59:03 -08:00
--> $DIR/pattern-errors.rs:20:17
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
|
LL | if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
LL + if let Some(&Some(&x)) = &Some(&mut Some(0)) {
|
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
error[E0308]: mismatched types
add test revisions for old-edition behavior of feature gates This also adds `#[cfg]` attributes to tests for bindings' types, to make it visually clearer which revisions type successfully.
2025-01-22 23:59:03 -08:00
--> $DIR/pattern-errors.rs:26:22
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
|
LL | if let Some(Some(&mut x)) = &Some(Some(&mut 0)) {
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - if let Some(Some(&mut x)) = &Some(Some(&mut 0)) {
LL + if let Some(Some(&x)) = &Some(Some(&mut 0)) {
|
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
error[E0308]: mismatched types
add test revisions for old-edition behavior of feature gates This also adds `#[cfg]` attributes to tests for bindings' types, to make it visually clearer which revisions type successfully.
2025-01-22 23:59:03 -08:00
--> $DIR/pattern-errors.rs:33:17
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
|
LL | if let Some(&mut Some(&_)) = &Some(&Some(0)) {
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - if let Some(&mut Some(&_)) = &Some(&Some(0)) {
LL + if let Some(&Some(&_)) = &Some(&Some(0)) {
|
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
error[E0308]: mismatched types
add test revisions for old-edition behavior of feature gates This also adds `#[cfg]` attributes to tests for bindings' types, to make it visually clearer which revisions type successfully.
2025-01-22 23:59:03 -08:00
--> $DIR/pattern-errors.rs:45:23
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
|
LL | if let Some(&Some(&mut _)) = &mut Some(&Some(0)) {
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - if let Some(&Some(&mut _)) = &mut Some(&Some(0)) {
LL + if let Some(&Some(&_)) = &mut Some(&Some(0)) {
|
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
error[E0308]: mismatched types
"classic2021" and "structural2021" rulesets: add eat-inherited-ref-alone deref rules
2025-01-25 23:32:12 -08:00
--> $DIR/pattern-errors.rs:56:17
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
|
LL | if let Some(&mut Some(x)) = &Some(Some(0)) {
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - if let Some(&mut Some(x)) = &Some(Some(0)) {
LL + if let Some(&Some(x)) = &Some(Some(0)) {
|
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
error[E0308]: mismatched types
"classic2021" and "structural2021" rulesets: add eat-inherited-ref-alone deref rules
2025-01-25 23:32:12 -08:00
--> $DIR/pattern-errors.rs:158:10
add more tests where the rulesets disagree These come directly from the "Compare" tab of Typing Rust Patterns, though they had to be split across multiple files. They're not comprehensive, but they do provide some previously-missing coverage and are easier to check against the spec. Possibly they should be split up some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm not sure how best to go about that.
2025-01-04 01:38:17 -08:00
|
LL | let [&mut x] = &[&mut 0];
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - let [&mut x] = &[&mut 0];
LL + let [&x] = &[&mut 0];
|
add more tests where the rulesets disagree These come directly from the "Compare" tab of Typing Rust Patterns, though they had to be split across multiple files. They're not comprehensive, but they do provide some previously-missing coverage and are easier to check against the spec. Possibly they should be split up some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm not sure how best to go about that.
2025-01-04 01:38:17 -08:00
error[E0308]: mismatched types
"classic2021" and "structural2021" rulesets: add eat-inherited-ref-alone deref rules
2025-01-25 23:32:12 -08:00
--> $DIR/pattern-errors.rs:164:10
add more tests where the rulesets disagree These come directly from the "Compare" tab of Typing Rust Patterns, though they had to be split across multiple files. They're not comprehensive, but they do provide some previously-missing coverage and are easier to check against the spec. Possibly they should be split up some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm not sure how best to go about that.
2025-01-04 01:38:17 -08:00
|
LL | let [&mut &x] = &[&mut 0];
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - let [&mut &x] = &[&mut 0];
LL + let [&&x] = &[&mut 0];
|
add more tests where the rulesets disagree These come directly from the "Compare" tab of Typing Rust Patterns, though they had to be split across multiple files. They're not comprehensive, but they do provide some previously-missing coverage and are easier to check against the spec. Possibly they should be split up some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm not sure how best to go about that.
2025-01-04 01:38:17 -08:00
error[E0308]: mismatched types
"classic2021" and "structural2021" rulesets: add eat-inherited-ref-alone deref rules
2025-01-25 23:32:12 -08:00
--> $DIR/pattern-errors.rs:170:10
add more tests where the rulesets disagree These come directly from the "Compare" tab of Typing Rust Patterns, though they had to be split across multiple files. They're not comprehensive, but they do provide some previously-missing coverage and are easier to check against the spec. Possibly they should be split up some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm not sure how best to go about that.
2025-01-04 01:38:17 -08:00
|
LL | let [&mut &ref x] = &[&mut 0];
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - let [&mut &ref x] = &[&mut 0];
LL + let [&&ref x] = &[&mut 0];
|
add more tests where the rulesets disagree These come directly from the "Compare" tab of Typing Rust Patterns, though they had to be split across multiple files. They're not comprehensive, but they do provide some previously-missing coverage and are easier to check against the spec. Possibly they should be split up some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm not sure how best to go about that.
2025-01-04 01:38:17 -08:00
error[E0308]: mismatched types
"classic2021" and "structural2021" rulesets: add eat-inherited-ref-alone deref rules
2025-01-25 23:32:12 -08:00
--> $DIR/pattern-errors.rs:176:10
add more tests where the rulesets disagree These come directly from the "Compare" tab of Typing Rust Patterns, though they had to be split across multiple files. They're not comprehensive, but they do provide some previously-missing coverage and are easier to check against the spec. Possibly they should be split up some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm not sure how best to go about that.
2025-01-04 01:38:17 -08:00
|
LL | let [&mut &(mut x)] = &[&mut 0];
| ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
Show diff suggestion format on verbose replacement ``` error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields --> $DIR/attempted-access-non-fatal.rs:7:15 | LL | let _ = 2.l; | ^ | help: if intended to be a floating point literal, consider adding a `0` after the period and a `f64` suffix | LL - let _ = 2.l; LL + let _ = 2.0f64; | ```
2024-07-09 22:30:26 +00:00
LL - let [&mut &(mut x)] = &[&mut 0];
LL + let [&&(mut x)] = &[&mut 0];
|
add more tests where the rulesets disagree These come directly from the "Compare" tab of Typing Rust Patterns, though they had to be split across multiple files. They're not comprehensive, but they do provide some previously-missing coverage and are easier to check against the spec. Possibly they should be split up some more, since `pattern-errors.rs` is getting a bit unwieldy, but I'm not sure how best to go about that.
2025-01-04 01:38:17 -08:00
minor test cleanup - Removes some excess parens - Removes 3 duplicated tests
2025-01-21 01:09:55 -08:00
error: aborting due to 10 previous errors
reorganize and comment some of the experimental pattern typing tests This only includes previously existing tests (with a couple duplicates removed). I plan on adding more comprarisons where the rules differ once I've updated the pattern typing rules. I also haven't touched the tests for new rules in old editions; I'll see how best to handle that once those rules are updated as well.
2024-12-23 18:38:14 -08:00
For more information about this error, try `rustc --explain E0308`.
Reference in New Issue Copy Permalink