#3057. Add more flow analysis tests for type Never. Part 2.

TypeSystem/flow-analysis/reachability_A01_t17.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
+/// - Variable or getter: If `N` is an expression of the form `x` where the
+///   type of `x` is `T` then:
+/// If `T <: Never` then:
+///   - Let `after(N) = unreachable(before(N))`.
+/// Otherwise:
+///   - Let `after(N) = before(N)`.
+///
+/// @description Checks that the code is unreachable after a variable of type
+/// `Never`. Test a list literal.
+/// @author sgrekhov22@gmail.com
+
+void test(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    [
+      n,        // The code after this point is unreachable
+      i = 42    // Variable is initialized in a dead code. This leaves it definitely unassigned
+    ];
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A01_t18.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
+/// - Variable or getter: If `N` is an expression of the form `x` where the
+///   type of `x` is `T` then:
+/// If `T <: Never` then:
+///   - Let `after(N) = unreachable(before(N))`.
+/// Otherwise:
+///   - Let `after(N) = before(N)`.
+///
+/// @description Checks that the code is unreachable after a variable of type
+/// `Never`. Test a set literal.
+/// @author sgrekhov22@gmail.com
+
+void test(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <Object>{
+      n,        // The code after this point is unreachable
+      i = 42    // Variable is initialized in a dead code. This leaves it definitely unassigned
+    };
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A01_t19.dart

@@ -0,0 +1,49 @@
+// 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
+/// - Variable or getter: If `N` is an expression of the form `x` where the
+///   type of `x` is `T` then:
+/// If `T <: Never` then:
+///   - Let `after(N) = unreachable(before(N))`.
+/// Otherwise:
+///   - Let `after(N) = before(N)`.
+///
+/// @description Checks that the code is unreachable after a variable of type
+/// `Never`. Test a map literal.
+/// @author sgrekhov22@gmail.com
+
+void test1(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <int, Object>{
+      1: n,        // The code after this point is unreachable
+      2: i = 42};   // Variable is initialized in a dead code. This leaves it definitely unassigned
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test2(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <Object, int>{
+      n:        // The code after this point is unreachable
+        i = 42  // Variable is initialized in a dead code. This leaves it definitely unassigned
+    };
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test1);
+  print(test2);
+}

TypeSystem/flow-analysis/reachability_A01_t20.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
+/// - Variable or getter: If `N` is an expression of the form `x` where the
+///   type of `x` is `T` then:
+/// If `T <: Never` then:
+///   - Let `after(N) = unreachable(before(N))`.
+/// Otherwise:
+///   - Let `after(N) = before(N)`.
+///
+/// @description Checks that the code is unreachable after a variable of type
+/// `Never`. Test an `if` element in a list literal.
+/// @author sgrekhov22@gmail.com
+
+void test(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    [
+      if (n is String)   // ignore: unnecessary_type_check
+        i = 42  // Variable is initialized in a dead code. This leaves it definitely unassigned
+    ];
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A01_t21.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
+/// - Variable or getter: If `N` is an expression of the form `x` where the
+///   type of `x` is `T` then:
+/// If `T <: Never` then:
+///   - Let `after(N) = unreachable(before(N))`.
+/// Otherwise:
+///   - Let `after(N) = before(N)`.
+///
+/// @description Checks that the code is unreachable after a variable of type
+/// `Never`. Test an `if` element in a set literal.
+/// @author sgrekhov22@gmail.com
+
+void test(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <Object>{
+      if (n is String) // ignore: unnecessary_type_check
+        i = 42 // Variable is initialized in a dead code. This leaves it definitely unassigned
+    };
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A01_t22.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
+/// - Variable or getter: If `N` is an expression of the form `x` where the
+///   type of `x` is `T` then:
+/// If `T <: Never` then:
+///   - Let `after(N) = unreachable(before(N))`.
+/// Otherwise:
+///   - Let `after(N) = before(N)`.
+///
+/// @description Checks that the code is unreachable after a variable of type
+/// `Never`. Test an `if` element in a map literal.
+/// @author sgrekhov22@gmail.com
+
+void test(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <int, int>{
+      if (n is String) // ignore: unnecessary_type_check
+        1: i = 42 // Variable is initialized in a dead code. This leaves it definitely unassigned
+    };
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A01_t23.dart

@@ -0,0 +1,83 @@
+// 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
+/// - Variable or getter: If `N` is an expression of the form `x` where the
+///   type of `x` is `T` then:
+/// If `T <: Never` then:
+///   - Let `after(N) = unreachable(before(N))`.
+/// Otherwise:
+///   - Let `after(N) = before(N)`.
+///
+/// @description Checks that the code is unreachable after a variable of type
+/// `Never`. Test a `for(;;)` element in a list literal.
+/// @author sgrekhov22@gmail.com
+/// @issue 60089
+
+void test1(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    [
+      for (n;;)  // The code after this point is unreachable
+        i = 42,  // Variable is initialized in a dead code. This leaves it definitely unassigned
+      i = 0
+    ];
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test2(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    [
+      for (;n;)  // The code after this point is unreachable
+        i = 42,
+      i = 0
+    ];
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test3(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    [
+      for (;; n)  // The code after this for statement is unreachable
+        i = 42,
+      i = 42
+    ];
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test4(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    [
+      for (var j = 0; j < 0; n)  // Ok, not a dead code
+        i = 42
+    ];
+  }
+  i; // Not an error
+}
+
+main() {
+  print(test1);
+  print(test2);
+  print(test3);
+  print(test4);
+}

TypeSystem/flow-analysis/reachability_A01_t24.dart

@@ -0,0 +1,83 @@
+// 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
+/// - Variable or getter: If `N` is an expression of the form `x` where the
+///   type of `x` is `T` then:
+/// If `T <: Never` then:
+///   - Let `after(N) = unreachable(before(N))`.
+/// Otherwise:
+///   - Let `after(N) = before(N)`.
+///
+/// @description Checks that the code is unreachable after a variable of type
+/// `Never`. Test a `for(;;)` element in a set literal.
+/// @author sgrekhov22@gmail.com
+/// @issue 60089
+
+void test1(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <int>{
+      for (n;;) // The code after this point is unreachable
+        i = 42, // Variable is initialized in a dead code. This leaves it definitely unassigned
+      i = 0
+    };
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test2(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <int>{
+      for (; n;) // The code after this point is unreachable
+        i = 42,
+      i = 0
+    };
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test3(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <int>{
+      for (;; n) // The code after this for statement is unreachable
+        i = 42,
+      i = 0
+    };
+  }
+  i; // It is an error to read a local late variable when it is definitely unassigned.
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+void test4(Never n) {
+  late int i;
+  bool b = (() => true)();
+  if (b) {
+    <int>{
+      for (var j = 0; j < 0; n) // Ok, not a dead code
+        i = 42
+    };
+  }
+  i; // Not an error
+}
+
+main() {
+  print(test1);
+  print(test2);
+  print(test3);
+  print(test4);
+}