[sound flow analysis] Implement behaviors for null check patterns.

This change updates the flow analysis logic for null check patterns,
so that when the language feature `sound-flow-analysis` is enabled,
the matched value type is checked for nullability. If it's
non-nullable, then the null check pattern is known to succeed.

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

Bug: #60438
Change-Id: Ie68d98d95e30053f992a3f8db6ccdd3978960eb7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/421583
Commit-Queue: Paul Berry <paulberry@google.com>
Reviewed-by: Chloe Stefantsova <cstefantsova@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>

Author: stereotype441

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

@@ -5219,14 +5219,17 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
   bool nullCheckOrAssertPattern_begin(
       {required bool isAssert, required Type matchedValueType}) {
     if (!isAssert) {
-      // Account for the possibility that the pattern might not match.  Note
-      // that it's tempting to skip this step if matchedValueType is
-      // non-nullable (based on the reasoning that a non-null value is
-      // guaranteed to satisfy a null check), but in weak mode that's not sound,
-      // because in weak mode even non-nullable values might be null.  We don't
-      // want flow analysis behavior to depend on mode, so we conservatively
-      // assume the pattern might not match regardless of matchedValueType.
-      _unmatched = _join(_unmatched, _current);
+      if (typeAnalyzerOptions.soundFlowAnalysisEnabled &&
+          operations.classifyType(matchedValueType) ==
+              TypeClassification.nonNullable) {
+        // The pattern is guaranteed to match.
+      } else {
+        // The pattern might not match, either because matchedValueType is
+        // nullable, or because sound flow analysis is disabled (in which case
+        // we presume the user might be running under an older version of Dart
+        // that supported weak null safety mode).
+        _unmatched = _join(_unmatched, _current);
+      }
     }
     FlowModel<Type>? ifNotNull =
         _nullCheckPattern(matchedValueType: matchedValueType);

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -11022,6 +11022,35 @@ main() {
         ]);
       });
     });
+
+    group('? pattern applied to non-nullable type', () {
+      test('When enabled, guaranteed to match', () {
+        h.run([
+          ifCase(expr('int'), wildcard().nullCheck..errorId = 'nullCheck', [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ]),
+        ], expectedErrors: {
+          'matchedTypeIsStrictlyNonNullable(pattern: nullCheck, '
+              'matchedType: int)'
+        });
+      });
+
+      test('When disabled, not guaranteed to match', () {
+        h.disableSoundFlowAnalysis();
+        h.run([
+          ifCase(expr('int'), wildcard().nullCheck..errorId = 'nullCheck', [
+            checkReachable(true),
+          ], [
+            checkReachable(true),
+          ]),
+        ], expectedErrors: {
+          'matchedTypeIsStrictlyNonNullable(pattern: nullCheck, '
+              'matchedType: int)'
+        });
+      });
+    });
   });
 }
 

pkg/front_end/test/spell_checking_list_code.txt

@@ -1347,6 +1347,7 @@ presented
 pressure
 presubmit
 presumably
+presume
 presuming
 prev
 primarily