Contradictory behavior from `body_might_complete_normally` about sdk HOT 4 CLOSED

This is a known issue. A similar situation was discussed in dart-lang/language#2977.

Every switch expression is subject to exhaustiveness checking, and the exhaustiveness analysis does recognize this case, so the following version of the code is accepted:

int add(int? a, int? b) => switch ((a, b)) {
      (_, null) => a!,
      (null, _) => b!,
      (final int a, final int b) => a + b
    };

However, exhaustiveness analysis is different from the flow analysis which is also performed, and the exhaustiveness analysis is stronger in some instances. So the declaration is accepted because it is subject to both kinds of analysis.

A switch statement is different: It is only subject to exhaustiveness analysis in the case where the static type of the scrutinee is an 'always-exhaustive type', and that doesn't include the record type (int?, int?), because it doesn't include int?.

This means that the switch statement is subject to flow analysis (that one is always enabled), but not to exhaustiveness analysis. And the flow analysis isn't smart enough to detect that this particular switch statement is exhaustive.

The issue dart-lang/language#2977 explicitly mentions this catch-22: If the default case is included then it is flagged as unreachable, but if it is omitted then the switch statement isn't recognized as being exhaustive.

There is no beautiful solution, but you might use something like the following:

int add(int? a, int? b) {
  switch ((a, b)) {
    case (_, null): return a!;
    case (null, _): return b!;
    case (final int a, final int b): return a + b;
  }
  // Flow analysis cannot see that the switch is exhaustive.
  throw "Unreachable";
}

from sdk.

Mm yeah. The way to comply with both of these is to add a final return outside the switch.

It's possible the body_might_complete_normally logic could be updated to treat switch statements as though they considered exhaustiveness...

from sdk.

It could have something to do with how records are analyzed, since having just 1 parameter works fine:

// no linter issues!
int increment(int? a) {
  switch (a) {
    case null: return 0;
    case final int a: return a + 1;
  }
}

from sdk.

Thank you @eernstg!

I think it makes sense to close this one as a duplicate of dart-lang/language#2977.

from sdk.