dart-lang#1401. Exhaustiveness tests added

Author: sgrekhov

LanguageFeatures/Patterns/exhaustiveness_A01_t01.dart

@@ -0,0 +1,45 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion But switch statements must only be exhaustive when the matched
+/// value is an always-exhaustive type, defined as:
+/// - bool
+/// - Null
+/// - A enum type
+/// - A type whose declaration is marked sealed
+/// - T? where T is always-exhaustive
+/// - FutureOr<T> for some type T that is always-exhaustive
+/// - A record type whose fields all have always-exhaustive types
+/// - A type variable X with bound T where T is always-exhaustive
+/// - A promoted type variable X & T where T is always-exhaustive
+///
+/// All other types are not always-exhaustive. Then:
+/// - It is a compile-time error if the cases in a switch statement or switch
+///   collection element are not exhaustive and the static type of the matched
+///   value is an always-exhaustive type. There is no error if a switch
+///   statement is not exhaustive when the type is not an always-exhaustive type
+///
+/// @description Check that it is a compile-time error if a switch statement is
+/// not exhaustive. Test `bool`
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+main() {
+  bool b = 1 > 2;
+  switch (b) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case true:
+  }
+  switch (b) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case false:
+      print("false");
+      break;
+  }
+}

LanguageFeatures/Patterns/exhaustiveness_A01_t02.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion But switch statements must only be exhaustive when the matched
+/// value is an always-exhaustive type, defined as:
+/// - bool
+/// - Null
+/// - A enum type
+/// - A type whose declaration is marked sealed
+/// - T? where T is always-exhaustive
+/// - FutureOr<T> for some type T that is always-exhaustive
+/// - A record type whose fields all have always-exhaustive types
+/// - A type variable X with bound T where T is always-exhaustive
+/// - A promoted type variable X & T where T is always-exhaustive
+///
+/// All other types are not always-exhaustive. Then:
+/// - It is a compile-time error if the cases in a switch statement or switch
+///   collection element are not exhaustive and the static type of the matched
+///   value is an always-exhaustive type. There is no error if a switch
+///   statement is not exhaustive when the type is not an always-exhaustive type
+///
+/// @description Check that it is a compile-time error if a switch statement is
+/// not exhaustive. Test `null`
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+main() {
+  switch (null) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  }
+}

LanguageFeatures/Patterns/exhaustiveness_A01_t03.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion But switch statements must only be exhaustive when the matched
+/// value is an always-exhaustive type, defined as:
+/// - bool
+/// - Null
+/// - A enum type
+/// - A type whose declaration is marked sealed
+/// - T? where T is always-exhaustive
+/// - FutureOr<T> for some type T that is always-exhaustive
+/// - A record type whose fields all have always-exhaustive types
+/// - A type variable X with bound T where T is always-exhaustive
+/// - A promoted type variable X & T where T is always-exhaustive
+///
+/// All other types are not always-exhaustive. Then:
+/// - It is a compile-time error if the cases in a switch statement or switch
+///   collection element are not exhaustive and the static type of the matched
+///   value is an always-exhaustive type. There is no error if a switch
+///   statement is not exhaustive when the type is not an always-exhaustive type
+///
+/// @description Check that it is a compile-time error if a switch statement is
+/// not exhaustive. Test an enum type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+enum E {
+  e1,
+  e2
+}
+
+main() {
+  E e = E.e1;
+  switch (e) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case E.e1:
+  }
+}

LanguageFeatures/Patterns/exhaustiveness_A01_t04.dart

@@ -0,0 +1,41 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion But switch statements must only be exhaustive when the matched
+/// value is an always-exhaustive type, defined as:
+/// - bool
+/// - Null
+/// - A enum type
+/// - A type whose declaration is marked sealed
+/// - T? where T is always-exhaustive
+/// - FutureOr<T> for some type T that is always-exhaustive
+/// - A record type whose fields all have always-exhaustive types
+/// - A type variable X with bound T where T is always-exhaustive
+/// - A promoted type variable X & T where T is always-exhaustive
+///
+/// All other types are not always-exhaustive. Then:
+/// - It is a compile-time error if the cases in a switch statement or switch
+///   collection element are not exhaustive and the static type of the matched
+///   value is an always-exhaustive type. There is no error if a switch
+///   statement is not exhaustive when the type is not an always-exhaustive type
+///
+/// @description Check that it is a compile-time error if a switch statement is
+/// not exhaustive. Test a type whose declaration is marked sealed
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns,class-modifiers
+
+sealed class Sealed {}
+class C1 extends Sealed {}
+class C2 extends Sealed {}
+
+main() {
+  Sealed s = C1();
+  switch (s) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case C1 _:
+  }
+}

LanguageFeatures/Patterns/exhaustiveness_A01_t05.dart

@@ -0,0 +1,48 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion But switch statements must only be exhaustive when the matched
+/// value is an always-exhaustive type, defined as:
+/// - bool
+/// - Null
+/// - A enum type
+/// - A type whose declaration is marked sealed
+/// - T? where T is always-exhaustive
+/// - FutureOr<T> for some type T that is always-exhaustive
+/// - A record type whose fields all have always-exhaustive types
+/// - A type variable X with bound T where T is always-exhaustive
+/// - A promoted type variable X & T where T is always-exhaustive
+///
+/// All other types are not always-exhaustive. Then:
+/// - It is a compile-time error if the cases in a switch statement or switch
+///   collection element are not exhaustive and the static type of the matched
+///   value is an always-exhaustive type. There is no error if a switch
+///   statement is not exhaustive when the type is not an always-exhaustive type
+///
+/// @description Check that it is a compile-time error if a switch statement is
+/// not exhaustive. Test a type `T?` where `T` is always-exhaustive
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns,class-modifiers
+
+main() {
+  bool? b = 1 > 2;
+  if (b) {
+    b = null;
+  }
+  switch (b) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case true:
+    case false:
+  }
+  switch (b) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case true:
+    case null:
+  }
+}

LanguageFeatures/Patterns/exhaustiveness_A01_t06.dart

@@ -0,0 +1,45 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion But switch statements must only be exhaustive when the matched
+/// value is an always-exhaustive type, defined as:
+/// - bool
+/// - Null
+/// - A enum type
+/// - A type whose declaration is marked sealed
+/// - T? where T is always-exhaustive
+/// - FutureOr<T> for some type T that is always-exhaustive
+/// - A record type whose fields all have always-exhaustive types
+/// - A type variable X with bound T where T is always-exhaustive
+/// - A promoted type variable X & T where T is always-exhaustive
+///
+/// All other types are not always-exhaustive. Then:
+/// - It is a compile-time error if the cases in a switch statement or switch
+///   collection element are not exhaustive and the static type of the matched
+///   value is an always-exhaustive type. There is no error if a switch
+///   statement is not exhaustive when the type is not an always-exhaustive type
+///
+/// @description Check that it is a compile-time error if a switch statement is
+/// not exhaustive. Test a type `FutureOr<T>` for `T` that is always-exhaustive
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "dart:async";
+
+main() {
+  FutureOr<bool> fo = true;
+  switch (fo) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case bool _:
+  }
+  switch (fo) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  case Future<bool> _:
+  }
+}

LanguageFeatures/Patterns/exhaustiveness_A01_t07.dart

@@ -0,0 +1,43 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion But switch statements must only be exhaustive when the matched
+/// value is an always-exhaustive type, defined as:
+/// - bool
+/// - Null
+/// - A enum type
+/// - A type whose declaration is marked sealed
+/// - T? where T is always-exhaustive
+/// - FutureOr<T> for some type T that is always-exhaustive
+/// - A record type whose fields all have always-exhaustive types
+/// - A type variable X with bound T where T is always-exhaustive
+/// - A promoted type variable X & T where T is always-exhaustive
+///
+/// All other types are not always-exhaustive. Then:
+/// - It is a compile-time error if the cases in a switch statement or switch
+///   collection element are not exhaustive and the static type of the matched
+///   value is an always-exhaustive type. There is no error if a switch
+///   statement is not exhaustive when the type is not an always-exhaustive type
+///
+/// @description Check that it is a compile-time error if a switch statement is
+/// not exhaustive. Test a record type whose fields all have always-exhaustive
+/// types
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns,records
+
+test((bool, {bool b}) r) {
+  switch (r) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case (true, b: true):
+    case (true, b: false):
+    case (false, b: true):
+  }
+}
+
+main() {
+  test((true, b: false));
+}

LanguageFeatures/Patterns/exhaustiveness_A01_t08.dart

@@ -0,0 +1,56 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion But switch statements must only be exhaustive when the matched
+/// value is an always-exhaustive type, defined as:
+/// - bool
+/// - Null
+/// - A enum type
+/// - A type whose declaration is marked sealed
+/// - T? where T is always-exhaustive
+/// - FutureOr<T> for some type T that is always-exhaustive
+/// - A record type whose fields all have always-exhaustive types
+/// - A type variable X with bound T where T is always-exhaustive
+/// - A promoted type variable X & T where T is always-exhaustive
+///
+/// All other types are not always-exhaustive. Then:
+/// - It is a compile-time error if the cases in a switch statement or switch
+///   collection element are not exhaustive and the static type of the matched
+///   value is an always-exhaustive type. There is no error if a switch
+///   statement is not exhaustive when the type is not an always-exhaustive type
+///
+/// @description Check that it is a compile-time error if a switch statement is
+/// not exhaustive. Test a type variable `X` with bound `T` where `T` is
+/// always-exhaustive
+/// @author [email protected]
+/// @issue 51887
+
+// SharedOptions=--enable-experiment=patterns,class-modifiers
+
+sealed class Sealed {}
+class C1 extends Sealed {}
+class C2 extends Sealed {}
+
+test1<T extends Sealed>() {
+  switch (T) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case C1:
+  }
+}
+
+test2<T extends bool?>() {
+  switch (T) {
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case bool:
+  }
+}
+
+main() {
+  test1<C1>();
+  test2<bool>();
+}