#3057. Add switch statement tests (#3121)

Add switch statement tests

Author: sgrekhov

TypeSystem/flow-analysis/reachability_switch_A01_t01.dart

@@ -0,0 +1,73 @@
+// Copyright (c) 2025, 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 switch statement: If `N` is a switch statement of the form
+/// `switch (E) {alternatives}` then:
+/// - Let `before(E) = before(N)`.
+/// - For each `C` in `alternatives` with statement body `S`:
+///   - If `C` is labelled let
+///     `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`
+///     otherwise let `before(S) = after(E)`.
+///  - If the cases are exhaustive, then let `after(N) = break(N)` otherwise let
+///    `after(N) = join(after(E), break(N))`.
+///
+/// @description Checks that if `E` has type `Never` then all `alternatives` are
+/// unreachable.
+/// @author [email protected]
+
+Never foo() => throw "Never";
+
+void test1() {
+  late int i;
+  if (2 > 1) {
+    switch (foo()) {
+      case 1:
+        i = 42;
+      default:
+        i = 42;
+    }
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test2(Never n) {
+  late int i;
+  if (2 > 1) {
+    switch (n) {
+      case 1:
+        i = 42;
+      default:
+        i = 42;
+    }
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test3<T extends Never>(T n) {
+  late int i;
+  if (2 > 1) {
+    switch (n) {
+      case 1:
+        i = 42;
+      default:
+        i = 42;
+    }
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test1);
+  print(test2);
+  print(test3);
+}

TypeSystem/flow-analysis/reachability_switch_A02_t01.dart

@@ -0,0 +1,28 @@
+// Copyright (c) 2025, 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 switch statement: If `N` is a switch statement of the form
+/// `switch (E) {alternatives}` then:
+/// - Let `before(E) = before(N)`.
+/// - For each `C` in `alternatives` with statement body `S`:
+///   - If `C` is labelled let
+///     `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`
+///     otherwise let `before(S) = after(E)`.
+///  - If the cases are exhaustive, then let `after(N) = break(N)` otherwise let
+///    `after(N) = join(after(E), break(N))`.
+///
+/// @description Checks that if `C` is labelled then
+/// `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`. Test
+/// that if `C` is labeled and a variable was assigned in `E` then it is
+/// definitely assigned in `S`.
+/// @author [email protected]
+
+void main() {
+  int i;
+  switch (i = 42) {
+    label: case 1:
+      i; // Definitely assigned
+    default:
+  }
+}

TypeSystem/flow-analysis/reachability_switch_A02_t02.dart

@@ -0,0 +1,57 @@
+// Copyright (c) 2025, 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 switch statement: If `N` is a switch statement of the form
+/// `switch (E) {alternatives}` then:
+/// - Let `before(E) = before(N)`.
+/// - For each `C` in `alternatives` with statement body `S`:
+///   - If `C` is labelled let
+///     `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`
+///     otherwise let `before(S) = after(E)`.
+///  - If the cases are exhaustive, then let `after(N) = break(N)` otherwise let
+///    `after(N) = join(after(E), break(N))`.
+///
+/// @description Checks that if `C` is labelled then
+/// `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`. Test
+/// that if `C` is labeled and a variable was assigned in `N` then  it is
+/// in a "possibly assigned" state in `S`.
+/// @author [email protected]
+
+void test1() {
+  late int i;
+  switch (42) {
+    case 1:
+      i = 42;
+    label: case 2:
+      i; // Possibly assigned
+    default:
+  }
+}
+
+void test2() {
+  late int i;
+  switch (42) {
+    label: case 1:
+      i;
+    case 2:
+      i = 42;
+    default:
+  }
+}
+
+void test3() {
+  late int i;
+  switch (42) {
+    label: case 1:
+      i;
+    default:
+      i = 42;
+  }
+}
+
+main() {
+  test1();
+  test2();
+  test3();
+}

TypeSystem/flow-analysis/reachability_switch_A02_t03.dart

@@ -0,0 +1,62 @@
+// Copyright (c) 2025, 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 switch statement: If `N` is a switch statement of the form
+/// `switch (E) {alternatives}` then:
+/// - Let `before(E) = before(N)`.
+/// - For each `C` in `alternatives` with statement body `S`:
+///   - If `C` is labelled let
+///     `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`
+///     otherwise let `before(S) = after(E)`.
+///  - If the cases are exhaustive, then let `after(N) = break(N)` otherwise let
+///    `after(N) = join(after(E), break(N))`.
+///
+/// @description Checks that if `C` is labelled then
+/// `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`. Test
+/// that if `C` is labeled and a variable was assigned in `N` then  it is
+/// in a "possibly assigned" state in `S`. Test object-pattern assignment.
+/// @author [email protected]
+
+class C {
+  final int v;
+  const C(this.v);
+}
+
+void test1() {
+  late int i;
+  switch (42) {
+    case 1:
+      C(v: i) = C(42);
+    label: case 2:
+      i; // Possibly assigned
+    default:
+  }
+}
+
+void test2() {
+  late int i;
+  switch (42) {
+    label: case 1:
+      i;
+    case 2:
+      C(v: i) = C(42);
+    default:
+  }
+}
+
+void test3() {
+  late int i;
+  switch (42) {
+    label: case 1:
+      i;
+    default:
+      C(v: i) = C(42);
+  }
+}
+
+main() {
+  test1();
+  test2();
+  test3();
+}

TypeSystem/flow-analysis/reachability_switch_A02_t04.dart

@@ -0,0 +1,62 @@
+// Copyright (c) 2025, 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 switch statement: If `N` is a switch statement of the form
+/// `switch (E) {alternatives}` then:
+/// - Let `before(E) = before(N)`.
+/// - For each `C` in `alternatives` with statement body `S`:
+///   - If `C` is labelled let
+///     `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`
+///     otherwise let `before(S) = after(E)`.
+///  - If the cases are exhaustive, then let `after(N) = break(N)` otherwise let
+///    `after(N) = join(after(E), break(N))`.
+///
+/// @description Checks that if `C` is labelled then
+/// `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`. Test
+/// that if `C` is labeled and a variable was assigned in `N` then  it is
+/// in a "possibly assigned" state in `S`. Test record-pattern assignment.
+/// @author [email protected]
+
+class C {
+  final int v;
+  const C(this.v);
+}
+
+void test1() {
+  late int i;
+  switch (42) {
+    case 1:
+      (i,) = (42,);
+    label: case 2:
+      i; // Possibly assigned
+    default:
+  }
+}
+
+void test2() {
+  late int i;
+  switch (42) {
+    label: case 1:
+      i;
+    case 2:
+      (x: i) = (x: 42);
+    default:
+  }
+}
+
+void test3() {
+  late int i;
+  switch (42) {
+    label: case 1:
+      i;
+    default:
+      (i,) = (42,);
+  }
+}
+
+main() {
+  test1();
+  test2();
+  test3();
+}

TypeSystem/flow-analysis/reachability_switch_A02_t05.dart

@@ -0,0 +1,34 @@
+// Copyright (c) 2025, 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 switch statement: If `N` is a switch statement of the form
+/// `switch (E) {alternatives}` then:
+/// - Let `before(E) = before(N)`.
+/// - For each `C` in `alternatives` with statement body `S`:
+///   - If `C` is labelled let
+///     `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`
+///     otherwise let `before(S) = after(E)`.
+///  - If the cases are exhaustive, then let `after(N) = break(N)` otherwise let
+///    `after(N) = join(after(E), break(N))`.
+///
+/// @description Checks that if `C` is labelled then
+/// `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`. Test
+/// that if `C` is labeled and a variable was assigned in `N` then  it is in a
+/// "possibly assigned" state in `after(N)`.
+/// @author [email protected]
+
+test() {
+  late int i;
+  switch (42) {
+    label: case 1:
+      break;
+      i = 42;
+    default:
+  }
+  i; // Possibly assigned
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_switch_A02_t06.dart

@@ -0,0 +1,43 @@
+// Copyright (c) 2025, 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 switch statement: If `N` is a switch statement of the form
+/// `switch (E) {alternatives}` then:
+/// - Let `before(E) = before(N)`.
+/// - For each `C` in `alternatives` with statement body `S`:
+///   - If `C` is labelled let
+///     `before(S) = conservativeJoin(after(E), assignedIn(N), capturedIn(N))`
+///     otherwise let `before(S) = after(E)`.
+///  - If the cases are exhaustive, then let `after(N) = break(N)` otherwise let
+///    `after(N) = join(after(E), break(N))`.
+///
+/// @description Checks that if a promoted variable was captured in `E` then it
+/// is demoted in `S`.
+/// @author [email protected]
+
+void test(int? n) {
+  if (n != null) {  // n promoted to int
+    switch ((){n = 42;}) { // n demoted to int?
+      label: case 1: // ignore: constant_pattern_never_matches_value_type
+        n.isEven;
+//        ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+      case 2: // ignore: constant_pattern_never_matches_value_type
+        n.isEven;
+//        ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+      default:
+        n.isEven;
+//        ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+    }
+  }
+}
+
+main() {
+  print(test);
+}