#3057. Add reachability tests for operators. Part 5. (#3105)

Add reachability tests for operators. Part 5.

Author: sgrekhov

TypeSystem/flow-analysis/reachability_A20_t105.dart

@@ -0,0 +1,26 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that for an expression of the form `E1 >>= E2`,
+/// `before(E2) = after(E1)`. Test that if `after(E1)` is unreachable then
+/// `before(E2)` is also unreachable.
+/// @author [email protected]
+
+void test<T extends Never>(T n) {
+  late int i;
+  if (2 > 1) {
+    n >>= (i = 42);
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A20_t106.dart

@@ -0,0 +1,31 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that if the static type of the expression of the form
+/// `E1 >>= E2` is `Never` then `after(N) = unreachable(after(E2))`.
+/// @author [email protected]
+
+class C {
+  Never operator >>(int other) => throw "";
+}
+
+void test() {
+  late int i;
+  if (2 > 1) {
+    C c = C();
+    c >>= 1;
+    i = 42;
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A20_t107.dart

@@ -0,0 +1,23 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that if the static type of the expression of the form
+/// `E1 >>= E2` is `Never` then `E2` is still reachable.
+/// @author [email protected]
+
+class C {
+  Never operator >>(int x) => throw "C";
+}
+
+main() {
+  late int i;
+  try {
+    C c = C();
+    c >>= (i = 42);
+  } catch (_) {}
+  i; // Not definitely unassigned
+}

TypeSystem/flow-analysis/reachability_A20_t108.dart

@@ -0,0 +1,25 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that for an expression of the form `E1 >>= E2` if the
+/// static type of `E1`is not `Never` then `after(N) = after(E2)`. This is
+/// tested by detecting that `i = 42` is considered to be guaranteed to have
+/// been executed when `i;` is executed.
+/// @author [email protected]
+
+class C {
+  num n;
+  C(this.n);
+  C operator >>(int other) => C(n - other);
+}
+
+main() {
+  int i;
+  C c = C(1);
+  c >>= (i = 42);
+  i; // Definitely assigned
+}

TypeSystem/flow-analysis/reachability_A20_t109.dart

@@ -0,0 +1,26 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that for an expression of the form `E1 >>>= E2`,
+/// `before(E2) = after(E1)`. Test that if `after(E1)` is unreachable then
+/// `before(E2)` is also unreachable.
+/// @author [email protected]
+
+void test<T extends Never>(T n) {
+  late int i;
+  if (2 > 1) {
+    n >>>= (i = 42);
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A20_t110.dart

@@ -0,0 +1,31 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that if the static type of the expression of the form
+/// `E1 >>>= E2` is `Never` then `after(N) = unreachable(after(E2))`.
+/// @author [email protected]
+
+class C {
+  Never operator >>>(int other) => throw "";
+}
+
+void test() {
+  late int i;
+  if (2 > 1) {
+    C c = C();
+    c >>>= 1;
+    i = 42;
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A20_t111.dart

@@ -0,0 +1,23 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that if the static type of the expression of the form
+/// `E1 >>>= E2` is `Never` then `E2` is still reachable.
+/// @author [email protected]
+
+class C {
+  Never operator >>>(int x) => throw "C";
+}
+
+main() {
+  late int i;
+  try {
+    C c = C();
+    c >>>= (i = 42);
+  } catch (_) {}
+  i; // Not definitely unassigned
+}

TypeSystem/flow-analysis/reachability_A20_t112.dart

@@ -0,0 +1,25 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that for an expression of the form `E1 >>>= E2` if the
+/// static type of `E1`is not `Never` then `after(N) = after(E2)`. This is
+/// tested by detecting that `i = 42` is considered to be guaranteed to have
+/// been executed when `i;` is executed.
+/// @author [email protected]
+
+class C {
+  num n;
+  C(this.n);
+  C operator >>>(int other) => C(n - other);
+}
+
+main() {
+  int i;
+  C c = C(1);
+  c >>>= (i = 42);
+  i; // Definitely assigned
+}

TypeSystem/flow-analysis/reachability_A20_t113.dart

@@ -0,0 +1,26 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that for an expression of the form `E1 <<= E2`,
+/// `before(E2) = after(E1)`. Test that if `after(E1)` is unreachable then
+/// `before(E2)` is also unreachable.
+/// @author [email protected]
+
+void test<T extends Never>(T n) {
+  late int i;
+  if (2 > 1) {
+    n <<= (i = 42);
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}

TypeSystem/flow-analysis/reachability_A20_t114.dart

@@ -0,0 +1,31 @@
+// 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 - Binary operator: All binary operators other than `==`, `&&`,
+/// `||`, and `??` are handled as calls to the appropriate `operator` method.
+///
+/// @description Checks that if the static type of the expression of the form
+/// `E1 <<= E2` is `Never` then `after(N) = unreachable(after(E2))`.
+/// @author [email protected]
+
+class C {
+  Never operator <<(int other) => throw "";
+}
+
+void test() {
+  late int i;
+  if (2 > 1) {
+    C c = C();
+    c <<= 1;
+    i = 42;
+  }
+  i; // Definitely unassigned
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(test);
+}