[sound flow analysis] Additional unit tests for patterns.

These unit tests exercise flow analysis behaviors for patterns that
one might plausibly assume are part of the `sound-flow-analysis`
feature, but actually have been present ever since the `patterns`
feature was introduced.

Adding these tests helps me be confident that the behavior of flow
analysis after `sound-flow-analysis` has all of the soundness
behaviors I expect; even though some of those behaviors aren't new.

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

Author: stereotype441

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -11600,6 +11600,145 @@ main() {
         ]);
       });
     });
+
+    group('Declared variable pattern with matching non-nullable types', () {
+      test('When enabled, guaranteed to match', () {
+        var x = Var('x');
+        h.run([
+          ifCase(expr('int'), x.pattern(type: 'int'), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+
+      test('When disabled, guaranteed to match', () {
+        // Flow analysis has considered `int x` as guaranteed to match a value
+        // with static type `int` since patterns were added to the language
+        // (even though that was not technically guaranteed to be the case when
+        // running in unsound null safety mode).
+        h.disableSoundFlowAnalysis();
+        var x = Var('x');
+        h.run([
+          ifCase(expr('int'), x.pattern(type: 'int'), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+    });
+
+    group('List pattern', () {
+      test('When enabled, guaranteed to match non-nullable list', () {
+        h.run([
+          ifCase(expr('List<int>'), listPattern([restPattern()]), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+
+      test('When disabled, guaranteed to match non-nullable list', () {
+        // Flow analysis has considered a list pattern as guaranteed to match a
+        // value with static type `List` since patterns were added to the
+        // language (even though that was not technically guaranteed to be the
+        // case when running in unsound null safety mode).
+        h.disableSoundFlowAnalysis();
+        h.run([
+          ifCase(expr('List<int>'), listPattern([restPattern()]), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+    });
+
+    group('Object pattern with matching non-nullable types', () {
+      test('When enabled, guaranteed to match', () {
+        h.run([
+          ifCase(expr('int'), objectPattern(requiredType: 'int', fields: []), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+
+      test('When disabled, guaranteed to match', () {
+        // Flow analysis has considered an object pattern as guaranteed to match
+        // a value with a matching static type since patterns were added to the
+        // language (even though that was not technically guaranteed to be the
+        // case when running in unsound null safety mode).
+        h.disableSoundFlowAnalysis();
+        h.run([
+          ifCase(expr('int'), objectPattern(requiredType: 'int', fields: []), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+    });
+
+    group('Record pattern with matching non-nullable type', () {
+      test('When enabled, guaranteed to match', () {
+        h.run([
+          ifCase(expr('(int,)'),
+              recordPattern([wildcard(type: 'int').recordField()]), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+
+      test('When disabled, guaranteed to match', () {
+        // Flow analysis has considered a record pattern as guaranteed to match
+        // a value with a matching static type since patterns were added to the
+        // language (even though that was not technically guaranteed to be the
+        // case when running in unsound null safety mode).
+        h.disableSoundFlowAnalysis();
+        h.run([
+          ifCase(expr('(int,)'),
+              recordPattern([wildcard(type: 'int').recordField()]), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+    });
+
+    group('Wildcard pattern with matching non-nullable types', () {
+      test('When enabled, guaranteed to match', () {
+        h.run([
+          ifCase(expr('int'), wildcard(type: 'int'), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+
+      test('When disabled, guaranteed to match', () {
+        // Flow analysis has considered `int _` as guaranteed to match a value
+        // with static type `int` since patterns were added to the language
+        // (even though that was not technically guaranteed to be the case when
+        // running in unsound null safety mode).
+        h.disableSoundFlowAnalysis();
+        h.run([
+          ifCase(expr('int'), wildcard(type: 'int'), [
+            checkReachable(true),
+          ], [
+            checkReachable(false),
+          ])
+        ]);
+      });
+    });
   });
 }