[sound flow analysis] Implement promoteForPattern behaviors.

This change updates the logic in the flow analysis method
`promoteForPattern`, so that when the language feature
`sound-flow-analysis` is enabled, the following additional behaviors
are added:

- If the matched value type is non-nullable, and the pattern
  implicitly performs an `is Null` test, then the pattern is known not
  to match.

- If the matched value type is `Null`, and the pattern implicitly
  performs an `is T` test, where `T` is a non-nullable type, then the
  pattern is known not to match. Note that this reasoning step is
  sound regardless of whether the program is running with sound null
  safety enabled, but since it is a new reasoning step, it only takes
  place if the `sound-flow-analysis` feature is enabled.

There is no behavioral change if the feature `sound-flow-analysis` is
disabled.

Bug: #60438
Change-Id: I5a6e8def050c95b6c1ad01d37584d17a0cd590c8
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/421900
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart

@@ -5341,12 +5341,33 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
       return false;
     }
 
-    if (operations.classifyType(matchedType) ==
-        TypeClassification.nonNullable) {
-      // The matched type is non-nullable, so promote to a non-nullable type.
-      // This allows for code like `case int? x?` to promote `x` to
-      // non-nullable.
-      knownType = operations.promoteToNonNull(knownType);
+    bool cannotMatch = false;
+    switch (operations.classifyType(matchedType)) {
+      case TypeClassification.nonNullable:
+        if (typeAnalyzerOptions.soundFlowAnalysisEnabled &&
+            operations.classifyType(knownType) ==
+                TypeClassification.nullOrEquivalent) {
+          // `Null()` cannot match a non-nullable matched value, assuming sound
+          // null safety.
+          cannotMatch = true;
+        }
+        // The matched type is non-nullable, so promote to a non-nullable type.
+        // This allows for code like `case int? x?` to promote `x` to
+        // non-nullable.
+        knownType = operations.promoteToNonNull(knownType);
+      case TypeClassification.nullOrEquivalent:
+        if (typeAnalyzerOptions.soundFlowAnalysisEnabled &&
+            operations.classifyType(knownType) ==
+                TypeClassification.nonNullable) {
+          // If `T` is a non-nullable type, `T()` cannot match a matched value
+          // of type `Null`. This reasoning step is sound regardless of whether
+          // sound null safety, but it is a new reasoning step that was added to
+          // flow analysis as part of the `sound-flow-analysis` feature.
+          cannotMatch = true;
+        }
+      case TypeClassification.potentiallyNullable:
+        // No conclusions can be drawn about `cannotMatch` or `knownType`.
+        break;
     }
     _PatternContext<Type> context = _stack.last as _PatternContext<Type>;
     _Reference<Type> matchedValueReference =
@@ -5384,6 +5405,9 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
           .ifFalse;
     }
     _current = ifTrue;
+    if (cannotMatch) {
+      _current = _current.setUnreachable();
+    }
     if (matchFailsIfWrongType && !coversMatchedType) {
       // There's a reachable control flow path where the match might fail due to
       // a type mismatch. Therefore, we must update the `_unmatched` flow state