Allow use switch expression to init a const variable

[huanghui1998hhh]

Example:

const fooNumber = int.fromEnvironment('NUMBER');

const fooString = switch (fooNumber) {
  1 => 'one',
  2 => 'two',
  3 => 'three',
  4 => 'four',
  _ => 'other',
}; //error

const fooString = fooNumber == 1
    ? 'one'
    : fooNumber == 2
        ? 'two'
        : fooNumber == 3
            ? 'three'
            : fooNumber == 4
                ? 'four'
                : 'other';

We have to nested ternary expression, it's terrible.

[dart-github-bot]

Summary: The user requests the ability to initialize a const variable using a switch expression, which is currently not allowed. This would simplify code compared to nested ternary expressions.

[lrhn]

This introduces the concept of a constant switch expression, which means constant patterns.
Not all patterns can be constant, but some can:

• _ obviously.
• Constant patterns with constant values that have primitive equality.
• Relational patterns on integers, and == patterns, which will be a compile-time error if the switch value doesn't have primitive equality.
• && and || combiners, ! and as <type> assertions (if the type is constant), ? null-check patterns.
• Type checking with a constant type. Both TheType() with not field accessors and TheType _ can work.
  • We could even allow String(length: > 0) since string.length is a valid constant expression.
• Maybe binding patterns. Without destructuring it's going to be an alias for the original value.

Not supported would be:

• Destructuring (object, map, list) patterns that actually extract something.. Those always require reading properties, which constant evaluation can't.
  • Maybe we can allow record patterns, because we know the property accesses are constant-safe. That makes binding patterns useful.
  • Maybe we can allow {} as an is Map check. Probably better to just require writing Map().
• Constant patterns with values that do not have primitive equality.

That is it, really. Not bad.

May want to allow record destructuring as a constant operation, so that when we get parameter patterns, you can write a constant constructor like const Point.fromPair(var (int x, int y)) : this.x = x, this.y = y;.

Nothing about this look particularly impossible.
It's just that we generally don't try to expand the constant sub-language much.