Discriminators as first class citizens of sum types

[goshacodes]

Consider following AST:

enum Foo(val discriminator: String):
  case Bar() extends Foo("bar")
  case Baz() extends Foo("baz")

"bar" and "baz" are literal constants, but now they are not exposed at compile time in any way.

So to make derivation of JsonReader (for example) possible I need to stub all case children instances and get this field.

I propose to:

1. Make this literal constants (if they are literal constants for all of the case children) visible at compile time in any way
2. If possible - expose this information to mirrors

So generation of this code could be possible without dirty hacks

given barJsonReader: JsonReader[Bar] = ???
given bazJsonReader: JsonReader[Baz] = ???

val discriminator = ???

discriminator match
  case "bar" =>
    barJsonReader
  case "baz" =>
    bazJsonReader
  

Why not use ordinal or MirroredElemLabels:

1. Enum ordinal is bound to ordinal, consider situation when developer changes order of case chilren (just because he doesn't like it) and deserialization starts failing at runtime

2. When you write integration with other software systems you often use provided by that system protocol, where discriminators can be strings and not bound in any way to ordinal of case children in your scala model

3. Case labels have same problem, they are bound to your case class name

[bishabosha]

2. If possible - expose this information to mirrors

The ordinal of an enum case is compile time information - its the index of the type in the MirroredElemTypes in the Mirror - which you can compute manually, or its the same as Tuple.Index[MirroredElemTypes, Baz]

[goshacodes]

I think this could be even thought as a language construct. Because this can really simplify life for both users and maintainers.
E.g. new keyword selector.

sealed trait Foo(selector name: String)

It is bound to sealed trait and enums parameter.
Only one field can be a selector
If it is used - all cases should provide this field as literal constant during extends
Information about this field can be accessed compile time

[bishabosha]

If we dont do that, then we already have a new tracked modifier for parameters under language.experimental.modularity - which can refine singleton types such as literal strings. combined with some parent class like DiscriminatedEnum it could define a parameter that a mirror could look for, and perform the uniqueness check. - I tried this in #21213 (with a bug)

[bishabosha]

or we could tell the mirror to specifically look for a tracked parameter of a specific name - which would have less boilerplate

[bishabosha]

but I do like the idea of the selector modifier, maybe worth a sip proposal

[goshacodes]

Let's try SIP