On Wed, Jun 23, 2021 at 12:51:34AM +0200, Mark Wielaard wrote:
> Finally, the The Rust Reference says "A tuple index is used to refer
> to the fields of tuples, tuple structs, and tuple variants." I don't
> understand how this would work for tuple variants. Does anybody have
> an example of how to refer to a tuple variant so a tuple index can be
> used on it?

Tom pointed out on irc that it doesn't seem possible to access enum
variant types except through a matching expression. The Rust Reference
also seems to be inconsistent. As mentioned above it mentions you can
use a tuple index to refer to a field of a enum tuple variant. But it
also says "A tuple indexing expression accesses fields of tuples and
tuple structs." So it probably really isn't possible to use a tuple
index on enum tuple variants.

I did notice the same issue as for unit tuple struct types. The empty
tuple wasn't accepted in the parser. The attached patch, also at
https://code.wildebeest.org/git/user/mjw/gccrs/commit/?h=tuple_enum_variant_unit
fixes this.

It does include a test case, but most of it is commented out because
actually resolving enum types isn't implemented yet. If you uncomment
the rest of the testcase you get:

tuple_enum_variants.rs:3:31: error: failed to resolve TypePath: E
    3 | fn f(e0: E, e1: E, e2: E) -> (E,E,E,())
      |                               ^
tuple_enum_variants.rs:3:31: error: unresolved type
tuple_enum_variants.rs:3:33: error: failed to resolve TypePath: E
    3 | fn f(e0: E, e1: E, e2: E) -> (E,E,E,())
      |                                 ^
tuple_enum_variants.rs:3:33: error: unresolved type
tuple_enum_variants.rs:3:35: error: failed to resolve TypePath: E
    3 | fn f(e0: E, e1: E, e2: E) -> (E,E,E,())
      |                                   ^
tuple_enum_variants.rs:3:35: error: unresolved type
tuple_enum_variants.rs:3:10: error: failed to resolve TypePath: E
    3 | fn f(e0: E, e1: E, e2: E) -> (E,E,E,())
      |          ^
tuple_enum_variants.rs:3:10: error: unresolved type
tuple_enum_variants.rs:3:17: error: failed to resolve TypePath: E
    3 | fn f(e0: E, e1: E, e2: E) -> (E,E,E,())
      |                 ^
tuple_enum_variants.rs:3:17: error: unresolved type
tuple_enum_variants.rs:3:24: error: failed to resolve TypePath: E
    3 | fn f(e0: E, e1: E, e2: E) -> (E,E,E,())
      |                        ^
tuple_enum_variants.rs:3:24: error: unresolved type
tuple_enum_variants.rs:13:12: error: unknown root segment in path E::T0 lookup E
   13 |   let e0 = E::T0();
      |            ^
tuple_enum_variants.rs:14:12: error: unknown root segment in path E::T1 lookup E
   14 |   let e1 = E::T1(0);
      |            ^
tuple_enum_variants.rs:15:12: error: unknown root segment in path E::T2 lookup E
   15 |   let e2 = E::T2(0,1);
      |            ^

Cheers,

Mark