Bad suggestion for tuple struct used in pattern with struct syntax and missing fields

[estebank]

For the following code:

struct S(i32, f32);
enum E {
    S(i32, f32),
}
fn main() {
    let x = E::S(1, 2.2);
    match x {
        E::S {} => {}
    }
    let y = S(1, 2.2);
    match y {
        S {} => {}
    }
}

we currently emit

error[E0027]: pattern does not mention fields `0`, `1`
 --> src/main.rs:8:9
  |
8 |         E::S {} => {}
  |         ^^^^^^^ missing fields `0`, `1`
  |
help: include the missing fields in the pattern
  |
8 |         E::S { 0, 1 } => {}
  |              ^^^^^^^^
help: if you don't care about these missing fields, you can explicitely ignore them
  |
8 |         E::S { .. } => {}
  |              ^^^^^^

error[E0027]: pattern does not mention fields `0`, `1`
  --> src/main.rs:12:9
   |
12 |         S {} => {}
   |         ^^^^ missing fields `0`, `1`
   |
help: include the missing fields in the pattern
   |
12 |         S { 0, 1 } => {}
   |           ^^^^^^^^
help: if you don't care about these missing fields, you can explicitely ignore them
   |
12 |         S { .. } => {}
   |           ^^^^^^

but struct patterns cannot refer to tuple field names with numbers, as the parser expects identifiers.

I think that 1) the parser should be changed to accept the positions, but ultimately reject them, suggesting to use the tuple syntax and 2) that the suggestion should be for the tuple syntax to begin with.

[reese]

Hey folks, I'd like to work on this ticket. One clarifying question: what's the best way to suggest proper syntax in this case? We can just tell them to use tuple syntax, but is there an effective way to give them an example? Something like this test for E0769 would be helpful, but I don't believe we'd know how many fields to expect while parsing. Is just suggesting tuple syntax like this enough here?

error[E0769]: expected field identifier, found tuple index
  --> src/main.rs:8:9
  |
8 |         E::S { 0, 1 } => {}
  |         ----   ^
  |         |
  |         while parsing the fields for this pattern
  |
   = help: use the tuple variant pattern syntax instead

For cases that parse but are caught in the type checker (where we currently return missing fields '0', '1'), I'd think suggesting tuple syntax and pointing back to the tuple definition (like this) would probably be enough, but happy to hear other thoughts.

[reese]

@rustbot claim

[estebank]

@reese hi! Thanks for taking this on!

I believe the ideal way to deal with this would be to make the Foo { 0, 1 } use valid in the parser and emit an explicit error when encountering it in a later step of the compiler. But that work is tangentially related (but important to tackle) to the one described on the ticket: this ticket was originally intended to stop suggesting Foo { 0, 1 } and instead suggest Foo(_, _) or similar. I think that the later is easier to implement, but if we can tackle both cases (accepting Foo { 0, 1 } syntactically with a suggestion to use Foo(a, b) and fixing the suggestion we currently give) that would be ideal. Would you be interested in doing both? It will certainly give you a good view of different parts of the compiler :)

[reese]

Ah okay, I see what you mean. Sure, I can definitely do both! Thanks for clarifying 👍