[cfe] Use exhaustiveness in computing nullability of intersection

This is a follow-up for
https://dart-review.googlesource.com/c/sdk/+/436620/comment/cddbbd38_1d23184c/

Change-Id: Ib473db14c6088ceb99034a6762ec75edccb4b5c1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/438723
Commit-Queue: Johnni Winther <[email protected]>
Auto-Submit: Chloe Stefantsova <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: chloestefantsova

pkg/kernel/lib/src/ast/types.dart

@@ -1888,53 +1888,37 @@ class IntersectionType extends DartType {
     // |     ?     | (!) | (?) | (%) |
     // |     %     |  !  |  %  |  %  |
 
-    if (lhsNullability == Nullability.nullable &&
-        rhsNullability == Nullability.nonNullable) {
-      return Nullability.nonNullable;
+    switch ((lhsNullability, rhsNullability)) {
+      case (Nullability.nullable, _):
+        return rhsNullability;
+
+      // Intersection with a non-nullable type always yields a non-nullable
+      // type, as it's the most restrictive kind of types.
+      case (Nullability.nonNullable, _):
+      case (_, Nullability.nonNullable):
+        return Nullability.nonNullable;
+
+      // If the nullability of LHS is 'undetermined', the nullability of the
+      // intersection is also 'undetermined' if RHS is 'undetermined' or
+      // nullable.
+      //
+      // Consider the following example:
+      //
+      //     class A<X extends Object?, Y extends X> {
+      //       foo(X x) {
+      //         if (x is Y) {
+      //           x = null;     // Compile-time error.  Consider X = Y = int.
+      //           Object a = x; // Compile-time error.  Consider X = Y = int?.
+      //         }
+      //         if (x is int?) {
+      //           x = null;     // Compile-time error.  Consider X = int.
+      //           Object b = x; // Compile-time error.  Consider X = int?.
+      //         }
+      //       }
+      //     }
+      case (Nullability.undetermined, _):
+        return Nullability.undetermined;
     }
-
-    if (lhsNullability == Nullability.nullable &&
-        rhsNullability == Nullability.nullable) {
-      return Nullability.nullable;
-    }
-
-    if (lhsNullability == Nullability.nullable &&
-        rhsNullability == Nullability.undetermined) {
-      return Nullability.undetermined;
-    }
-
-    // Intersection with a non-nullable type always yields a non-nullable type,
-    // as it's the most restrictive kind of types.
-    if (lhsNullability == Nullability.nonNullable ||
-        rhsNullability == Nullability.nonNullable) {
-      return Nullability.nonNullable;
-    }
-
-    // If the nullability of LHS is 'undetermined', the nullability of the
-    // intersection is also 'undetermined' if RHS is 'undetermined' or
-    // nullable.
-    //
-    // Consider the following example:
-    //
-    //     class A<X extends Object?, Y extends X> {
-    //       foo(X x) {
-    //         if (x is Y) {
-    //           x = null;     // Compile-time error.  Consider X = Y = int.
-    //           Object a = x; // Compile-time error.  Consider X = Y = int?.
-    //         }
-    //         if (x is int?) {
-    //           x = null;     // Compile-time error.  Consider X = int.
-    //           Object b = x; // Compile-time error.  Consider X = int?.
-    //         }
-    //       }
-    //     }
-    if (lhsNullability == Nullability.undetermined ||
-        rhsNullability == Nullability.undetermined) {
-      return Nullability.undetermined;
-    }
-
-    throw new StateError("Unsupported combination '${lhsNullability}' (LHS) "
-        "and '${rhsNullability}' (RHS).");
   }
 
   @override