#2080. Add correct member overrides tests. Part 2. Setters (#2093)

Author: sgrekhov

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t06.dart

@@ -47,7 +47,7 @@ class C2 implements I1, I2, I3 {
 // [cfe] unspecified
 
   void m2(int v1, {String s0 = ""}) {}
-//     ^
+//     ^^
 // [analyzer] unspecified
 // [cfe] unspecified
 }

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t19.dart

@@ -0,0 +1,39 @@
+// 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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is a compile-time error if `m` and `m′` are both
+/// setters and function type `m` is not a subtype of `m′`. Test `implements`
+/// clause
+/// @author [email protected]
+
+interface class I {
+  void set m(num n) {}
+}
+
+class C implements I {
+  void set m(int i) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M implements I {
+  void set m(int i) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+  print(M);
+}

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t20.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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is a compile-time error if `m` and `m′` are both
+/// setters and function type `m` is not a subtype of `m′`. Test `implements`
+/// clause
+/// @author [email protected]
+
+interface class I1 {
+  void set m(int i) {}
+}
+
+interface class I2 {
+  void set m(Object i) {}
+}
+
+class C implements I1, I2 {
+  void set m(num i) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M implements I1, I2 {
+  void set m(num i) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+  print(M);
+}

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t21.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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is not an error if `m` and `m′` are both setters
+/// and function type `m` is a subtype of `m′. Test `implements` clause
+/// @author [email protected]
+
+interface class I {
+  void set m1(num v1) {}
+  void set m2(covariant int v1) {}
+}
+
+class C implements I {
+  void set m1(covariant int i) {}
+  void set m2(num i) {}
+}
+
+mixin M implements I {
+  void set m1(covariant int i) {}
+  void set m2(num i) {}
+}
+
+main() {
+  print(C);
+  print(M);
+}

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t22.dart

@@ -0,0 +1,36 @@
+// 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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is not an error if `m` and `m′` are both setters
+/// and function type `m` is a subtype of `m′. Test `implements` clause
+/// @author [email protected]
+
+interface class I1 {
+  void set m(num v1) {}
+}
+
+interface class I2 {
+  void set m(covariant int v1) {}
+}
+
+class C implements I1, I2 {
+  void set m(covariant int i) {}
+}
+
+mixin M implements I1, I2 {
+  void set m(num i) {}
+}
+
+main() {
+  print(C);
+  print(M);
+}

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t23.dart

@@ -0,0 +1,50 @@
+// 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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is a compile-time error if `m` and `m′` are both
+/// setters and function type `m` is not a subtype of `m′. Test `implements`
+/// clause
+/// @author [email protected]
+
+interface class I {
+  void set m1(num v1) {}
+  void set m2(covariant int v1) {}
+}
+
+class C implements I {
+  void set m1(covariant String i) {}
+//         ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void set m2(String i) {}
+//         ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M implements I {
+  void set m1(covariant String i) {}
+//         ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void set m2(String i) {}
+//         ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+  print(M);
+}

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t24.dart

@@ -0,0 +1,39 @@
+// 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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is a compile-time error if `m` and `m′` are both
+/// setters and function type `m` is not a subtype of `m′`. Test `extends` and
+/// `on` clauses
+/// @author [email protected]
+
+interface class I {
+  void set m(num n) {}
+}
+
+class C extends I {
+  void set m(int i) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M on I {
+  void set m(int i) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+  print(M);
+}

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t25.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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is a compile-time error if `m` and `m′` are both
+/// setters and function type `m` is not a subtype of `m′`. Test `extends` and
+/// `on` clauses
+/// @author [email protected]
+
+interface class I1 {
+  void set m(int i) {}
+}
+
+interface class I2 {
+  void set m(Object i) {}
+}
+
+class C extends I1 implements I2 {
+  void set m(num i) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+mixin M on I2 implements I1 {
+  void set m(num i) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+  print(M);
+}

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t26.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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is not an error if `m` and `m′` are both setters
+/// and function type `m` is a subtype of `m′. Test `extends` and `on` clauses
+/// @author [email protected]
+
+interface class I {
+  void set m1(num v1) {}
+  void set m2(covariant int v1) {}
+}
+
+class C extends I {
+  void set m1(covariant int i) {}
+  void set m2(num i) {}
+}
+
+mixin M on I {
+  void set m1(covariant int i) {}
+  void set m2(num i) {}
+}
+
+main() {
+  print(C);
+  print(M);
+}

Language/Interfaces/Correct_Member_Overrides/correct_member_overrides_A03_t27.dart

@@ -0,0 +1,36 @@
+// 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 Let m and m′ be member signatures with the same name id. Then m
+/// is a correct override of m′ iff the following criteria are all satisfied:
+/// ...
+/// • If m and m′ are both methods or both setters: Let F be the function type
+/// of m except that the parameter type is the built-in class Object for each
+/// parameter of m which is covariant-by-declaration. Let F′ be the function
+/// type of m′. F must then be a subtype of F′.
+///
+/// @description Checks that it is not an error if `m` and `m′` are both setters
+/// and function type `m` is a subtype of `m′. Test `extends` and `on` clauses
+/// @author [email protected]
+
+interface class I1 {
+  void set m(num v1) {}
+}
+
+interface class I2 {
+  void set m(covariant int v1) {}
+}
+
+class C extends I1 implements I2 {
+  void set m(covariant int i) {}
+}
+
+mixin M on I2 implements I1 {
+  void set m(num i) {}
+}
+
+main() {
+  print(C);
+  print(M);
+}