Issue 35710. Test switch exhaustiveness, improve for null.

Bug: #35710
Change-Id: I6f17db1a9b2c01ec4b97538e224146fd3cec9002
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/149606
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/generated/resolver.dart

@@ -2901,10 +2901,15 @@ class VariableResolverVisitor extends ScopedVisitor {
 /// Tracker for whether a `switch` statement has `default` or is on an
 /// enumeration, and all the enum constants are covered.
 class _SwitchExhaustiveness {
-  /// If the switch is on an enumeration, the set of all enum constants.
+  /// If the switch is on an enumeration, the set of enum constants to cover.
   /// Otherwise `null`.
   final Set<FieldElement> _enumConstants;
 
+  /// If the switch is on an enumeration, is `true` if the null value is
+  /// covered, because the switch expression type is non-nullable, or `null`
+  /// was covered explicitly.
+  bool _isNullEnumValueCovered = false;
+
   bool isExhaustive = false;
 
   factory _SwitchExhaustiveness(DartType expressionType) {
@@ -2913,22 +2918,28 @@ class _SwitchExhaustiveness {
       if (enum_ is EnumElementImpl) {
         return _SwitchExhaustiveness._(
           enum_.constants.toSet(),
+          expressionType.nullabilitySuffix == NullabilitySuffix.none,
         );
       }
     }
-    return _SwitchExhaustiveness._(null);
+    return _SwitchExhaustiveness._(null, false);
   }
 
-  _SwitchExhaustiveness._(this._enumConstants);
+  _SwitchExhaustiveness._(this._enumConstants, this._isNullEnumValueCovered);
 
   void visitSwitchMember(SwitchMember node) {
     if (_enumConstants != null && node is SwitchCase) {
       var element = _referencedElement(node.expression);
       if (element is PropertyAccessorElement) {
         _enumConstants.remove(element.variable);
-        if (_enumConstants.isEmpty) {
-          isExhaustive = true;
-        }
+      }
+
+      if (node.expression is NullLiteral) {
+        _isNullEnumValueCovered = true;
+      }
+
+      if (_enumConstants.isEmpty && _isNullEnumValueCovered) {
+        isExhaustive = true;
       }
     } else if (node is SwitchDefault) {
       isExhaustive = true;

pkg/analyzer/test/src/diagnostics/body_might_complete_normally_test.dart

@@ -64,6 +64,89 @@ Iterable<int> foo() sync* {}
 ''');
   }
 
+  test_function_nonNullable_blockBody_switchStatement_notNullable_exhaustive() async {
+    await assertNoErrorsInCode(r'''
+enum Foo { a, b }
+
+int f(Foo foo) {
+  switch (foo) {
+    case Foo.a:
+      return 0;
+    case Foo.b:
+      return 1;
+  }
+}
+''');
+  }
+
+  test_function_nonNullable_blockBody_switchStatement_notNullable_notExhaustive() async {
+    await assertErrorsInCode(r'''
+enum Foo { a, b }
+
+int f(Foo foo) {
+  switch (foo) {
+    case Foo.a:
+      return 0;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.BODY_MIGHT_COMPLETE_NORMALLY, 23, 1),
+      error(StaticWarningCode.MISSING_ENUM_CONSTANT_IN_SWITCH, 38, 12),
+    ]);
+  }
+
+  test_function_nonNullable_blockBody_switchStatement_nullable_exhaustive_default() async {
+    await assertNoErrorsInCode(r'''
+enum Foo { a, b }
+
+int f(Foo? foo) {
+  switch (foo) {
+    case Foo.a:
+      return 0;
+    case Foo.b:
+      return 1;
+    default:
+      return 2;
+  }
+}
+''');
+  }
+
+  test_function_nonNullable_blockBody_switchStatement_nullable_exhaustive_null() async {
+    await assertNoErrorsInCode(r'''
+enum Foo { a, b }
+
+int f(Foo? foo) {
+  switch (foo) {
+    case null:
+      return 0;
+    case Foo.a:
+      return 1;
+    case Foo.b:
+      return 2;
+  }
+}
+''');
+  }
+
+  test_function_nonNullable_blockBody_switchStatement_nullable_notExhaustive_null() async {
+    await assertErrorsInCode(r'''
+enum Foo { a, b }
+
+int f(Foo? foo) {
+  switch (foo) {
+    case Foo.a:
+      return 0;
+    case Foo.b:
+      return 1;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.BODY_MIGHT_COMPLETE_NORMALLY, 23, 1),
+      error(StaticWarningCode.MISSING_ENUM_CONSTANT_IN_SWITCH, 39, 12),
+    ]);
+  }
+
   test_function_nullable_blockBody() async {
     await assertNoErrorsInCode(r'''
 int foo() {