[beta] Patterns flow analysis: recognize [...] (and related patterns) as trivially exhaustive.

If a list pattern consists of a single rest pattern, and that rest
pattern is guaranteed to match, then the whole list pattern is
guaranteed to match as well (provided that the matched value type is a
subtype of the list pattern's required type).

Bug: dart-lang/language#2980
Change-Id: Ibdd3b2315676e763a0c44b6c0adf7ac528d349e3
Cherry-pick: https://dart-review.googlesource.com/c/sdk/+/294622
Fixes: #52018
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/294682
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart

@@ -800,7 +800,8 @@ mixin TypeAnalyzer<
     flow.promoteForPattern(
         matchedType: matchedType,
         knownType: requiredType,
-        matchMayFailEvenIfCorrectType: true);
+        matchMayFailEvenIfCorrectType:
+            !(elements.length == 1 && isRestPatternElement(elements[0])));
     // Stack: ()
     Node? previousRestPattern;
     Map<int, Error>? duplicateRestPatternErrors;

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -7481,15 +7481,65 @@ main() {
     });
 
     group('List pattern:', () {
-      test('Not guaranteed to match', () {
-        h.run([
-          switch_(expr('Object'), [
-            listPattern([]).then([break_()]),
-            default_.then([
-              checkReachable(true),
+      group('Not guaranteed to match:', () {
+        test('Empty list', () {
+          h.run([
+            switch_(expr('List<Object>'), [
+              listPattern([]).then([break_()]),
+              default_.then([
+                checkReachable(true),
+              ]),
             ]),
-          ]),
-        ]);
+          ]);
+        });
+
+        test('Single non-rest element', () {
+          h.run([
+            switch_(expr('List<Object>'), [
+              listPattern([wildcard()]).then([break_()]),
+              default_.then([
+                checkReachable(true),
+              ]),
+            ]),
+          ]);
+        });
+
+        test('Rest pattern with subpattern that may fail to match', () {
+          h.run([
+            switch_(expr('List<Object>'), [
+              listPattern([listPatternRestElement(listPattern([]))])
+                  .then([break_()]),
+              default_.then([
+                checkReachable(true),
+              ])
+            ])
+          ]);
+        });
+      });
+
+      group('Guaranteed to match:', () {
+        test('Rest pattern with no subpattern', () {
+          h.run([
+            switch_(expr('List<Object>'), [
+              listPattern([listPatternRestElement()]).then([break_()]),
+              default_.then([
+                checkReachable(false),
+              ])
+            ])
+          ]);
+        });
+
+        test('Rest pattern with subpattern that always matches', () {
+          h.run([
+            switch_(expr('List<Object>'), [
+              listPattern([listPatternRestElement(wildcard())])
+                  .then([break_()]),
+              default_.then([
+                checkReachable(false),
+              ])
+            ])
+          ]);
+        });
       });
 
       test('Promotes', () {

tests/language/patterns/switch_trivial_exhaustiveness_error_test.dart

@@ -128,44 +128,44 @@ void testListContainingRestPatternAndNonRestPattern(List<Object> x) {
 }
 
 void testListContainingOnlyRestPattern(List<Object> x) {
-  // TODO(paulberry): this should be trivially exhaustive
+  // Trivially exhaustive
   bool? y;
   switch (x) {
     case [...]:
       y = true;
   }
-  y.expectStaticType<Exactly<bool?>>();
+  y.expectStaticType<Exactly<bool>>();
 }
 
 void testListContainingOnlyRestPatternWithSubpatternWildcard(List<Object> x) {
-  // TODO(paulberry): this should be trivially exhaustive
+  // Trivially exhaustive
   bool? y;
   switch (x) {
     case [..._]:
       y = true;
   }
-  y.expectStaticType<Exactly<bool?>>();
+  y.expectStaticType<Exactly<bool>>();
 }
 
 void testListContainingOnlyRestPatternWithSubpatternAnyList(List<Object> x) {
-  // TODO(paulberry): this should be trivially exhaustive
+  // Trivially exhaustive
   bool? y;
   switch (x) {
     case [...[...]]:
       y = true;
   }
-  y.expectStaticType<Exactly<bool?>>();
+  y.expectStaticType<Exactly<bool>>();
 }
 
 void testListContainingOnlyRestPatternWithSubpatternObjectPattern(
     List<Object> x) {
-  // TODO(paulberry): this should be trivially exhaustive
+  // Trivially exhaustive
   bool? y;
   switch (x) {
     case [...List()]:
       y = true;
   }
-  y.expectStaticType<Exactly<bool?>>();
+  y.expectStaticType<Exactly<bool>>();
 }
 
 void testListContainingOnlyRestPatternWithSubpatternOther(List<Object> x) {
@@ -179,13 +179,13 @@ void testListContainingOnlyRestPatternWithSubpatternOther(List<Object> x) {
 }
 
 void testListSupertype(List<Object> x) {
-  // TODO(paulberry): this should be trivially exhaustive
+  // Trivially exhaustive
   bool? y;
   switch (x) {
     case <Object?>[...]:
       y = true;
   }
-  y.expectStaticType<Exactly<bool?>>();
+  y.expectStaticType<Exactly<bool>>();
 }
 
 void testListSubtype(List<Object> x) {