#2087. Add tests for parameters covariant-by-declaration (#2121)

Add tests for parameters covariant-by-declaration

Author: sgrekhov

Language/Classes/Instance_Methods/covariant_A01_t01.dart

@@ -0,0 +1,61 @@
+// 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 For each parameter p of m where covariant is present, it is a
+/// compile-time error if there exists a direct or indirect superinterface of C
+/// which has an accessible method signature m′′ with the same name as m, such
+/// that m′′ has a parameter p′′ that corresponds to p, unless the type of p is
+/// a subtype or a supertype of the type of p′′
+///
+/// @description Checks that it is a compile-time error if there is a member
+/// with a covariant parameter `p` and there is another member with the same
+/// name but with the parameter which is not a subtype or supertype of `p`
+/// @author [email protected]
+
+class A {
+  void m1(num a) {}
+  void m2([num a = 0]) {}
+  void m3({num a = 0}) {}
+  void m4({required num a}) {}
+
+  void set s(num n) {}
+
+  void operator +(num n) {}
+}
+
+class C extends A {
+  void m1(covariant String a) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m2([covariant String a = ""]) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m3({covariant String a = ""}) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m4({required covariant String a}) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void set s(covariant String s) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void operator +(covariant String n) {}
+//              ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+}

Language/Classes/Instance_Methods/covariant_A01_t02.dart

@@ -0,0 +1,38 @@
+// 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 For each parameter p of m where covariant is present, it is a
+/// compile-time error if there exists a direct or indirect superinterface of C
+/// which has an accessible method signature m′′ with the same name as m, such
+/// that m′′ has a parameter p′′ that corresponds to p, unless the type of p is
+/// a subtype or a supertype of the type of p′′
+///
+/// @description Checks that it is not an error if there is a member
+/// with a covariant parameter `p` and there is another member with the same
+/// name but with the parameter which is a subtype of `p`
+/// @author [email protected]
+
+class A {
+  void m1(num a) {}
+  void m2([num a = 0]) {}
+  void m3({num a = 0}) {}
+  void m4({required num a}) {}
+
+  void set s(num n) {}
+  void operator +(num n) {}
+}
+
+class C extends A {
+  void m1(covariant Object a) {}
+  void m2([covariant Object a = ""]) {}
+  void m3({covariant Object a = ""}) {}
+  void m4({required covariant Object a}) {}
+
+  void set s(covariant Object s) {}
+  void operator +(covariant Object n) {}
+}
+
+main() {
+  print(C);
+}

Language/Classes/Instance_Methods/covariant_A01_t03.dart

@@ -0,0 +1,38 @@
+// 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 For each parameter p of m where covariant is present, it is a
+/// compile-time error if there exists a direct or indirect superinterface of C
+/// which has an accessible method signature m′′ with the same name as m, such
+/// that m′′ has a parameter p′′ that corresponds to p, unless the type of p is
+/// a subtype or a supertype of the type of p′′
+///
+/// @description Checks that it is not an error if there is a member with a
+/// covariant parameter `p` and there is another member with the same name but
+/// with the parameter which is a supertype of `p`
+/// @author [email protected]
+
+class A {
+  void m1(num a) {}
+  void m2([num a = 0]) {}
+  void m3({num a = 0}) {}
+  void m4({required num a}) {}
+
+  void set s(num n) {}
+  void operator +(num n) {}
+}
+
+class C extends A {
+  void m1(covariant int a) {}
+  void m2([covariant int a = 1]) {}
+  void m3({covariant int a = 1}) {}
+  void m4({required covariant int a}) {}
+
+  void set s(covariant int s) {}
+  void operator +(covariant int n) {}
+}
+
+main() {
+  print(C);
+}

Language/Classes/Instance_Methods/covariant_A01_t04.dart

@@ -0,0 +1,60 @@
+// 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 For each parameter p of m where covariant is present, it is a
+/// compile-time error if there exists a direct or indirect superinterface of C
+/// which has an accessible method signature m′′ with the same name as m, such
+/// that m′′ has a parameter p′′ that corresponds to p, unless the type of p is
+/// a subtype or a supertype of the type of p′′
+///
+/// @description Checks that it is a compile-time error if there is a member
+/// with a covariant parameter `p` and there is another member with the same
+/// name but with the parameter which is not a subtype or supertype of `p`
+/// @author [email protected]
+
+class A {
+  void m1(covariant num a) {}
+  void m2([covariant num a = 0]) {}
+  void m3({covariant a = 0}) {}
+  void m4({required covariant num a}) {}
+
+  void set s(covariant num n) {}
+  void operator +(covariant num n) {}
+}
+
+class C extends A {
+  void m1(String a) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m2([String a = ""]) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m3({String a = ""}) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m4({required String a}) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void set s(String s) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void operator +(String n) {}
+//              ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+}

Language/Classes/Instance_Methods/covariant_A01_t05.dart

@@ -0,0 +1,70 @@
+// 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 For each parameter p of m where covariant is present, it is a
+/// compile-time error if there exists a direct or indirect superinterface of C
+/// which has an accessible method signature m′′ with the same name as m, such
+/// that m′′ has a parameter p′′ that corresponds to p, unless the type of p is
+/// a subtype or a supertype of the type of p′′
+///
+/// @description Checks that it is a compile-time error if there is a member
+/// with a covariant parameter `p` and there is another member with the same
+/// name but with the parameter which is not a subtype or supertype of `p`
+/// @author [email protected]
+
+class A {
+  void m1(num a) {}
+  void m2([num a = 0]) {}
+  void m3({a = 0}) {}
+  void m4({required num a}) {}
+
+  void set s(num n) {}
+  void operator +(num n) {}
+}
+
+abstract class B {
+  void m1(covariant String a);
+  void m2([covariant String a = ""]);
+  void m3({covariant String a = ""});
+  void m4({required covariant String a});
+
+  void set s(covariant String s);
+  void operator +(covariant String n);
+}
+
+class C extends A implements B {
+  void m1(int a) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m2([int a = 1]) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m3({int a = 1}) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m4({required int a}) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void set s(int s) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void operator +(int n) {}
+//              ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+}

Language/Classes/Instance_Methods/covariant_A01_t06.dart

@@ -0,0 +1,70 @@
+// 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 For each parameter p of m where covariant is present, it is a
+/// compile-time error if there exists a direct or indirect superinterface of C
+/// which has an accessible method signature m′′ with the same name as m, such
+/// that m′′ has a parameter p′′ that corresponds to p, unless the type of p is
+/// a subtype or a supertype of the type of p′′
+///
+/// @description Checks that it is a compile-time error if there is a member
+/// with a covariant parameter `p` and there is another member with the same
+/// name but with the parameter which is not a subtype or supertype of `p`
+/// @author [email protected]
+
+class A {
+  void m1(num a) {}
+  void m2([num a = 0]) {}
+  void m3({a = 0}) {}
+  void m4({required num a}) {}
+
+  void set s(num n) {}
+  void operator +(num n) {}
+}
+
+abstract mixin class B {
+  void m1(covariant String a);
+  void m2([covariant String a = ""]);
+  void m3({covariant String a = ""});
+  void m4({required covariant String a});
+
+  void set s(covariant String s);
+  void operator +(covariant String n);
+}
+
+class C extends A with B {
+  void m1(int a) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m2([int a = 1]) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m3({int a = 1}) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void m4({required int a}) {}
+//     ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void set s(int s) {}
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  void operator +(int n) {}
+//              ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  print(C);
+}

Language/Classes/Instance_Methods/covariant_A01_t07.dart

@@ -0,0 +1,38 @@
+// 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 For each parameter p of m where covariant is present, it is a
+/// compile-time error if there exists a direct or indirect superinterface of C
+/// which has an accessible method signature m′′ with the same name as m, such
+/// that m′′ has a parameter p′′ that corresponds to p, unless the type of p is
+/// a subtype or a supertype of the type of p′′
+///
+/// @description Checks that it is not an error if there is a member
+/// with a covariant parameter `p` and there is another member with the same
+/// name but with the parameter which is a subtype of `p`
+/// @author [email protected]
+
+class A {
+  void m1(covariant Object a) {}
+  void m2([covariant Object a = ""]) {}
+  void m3({covariant Object a = ""}) {}
+  void m4({required covariant Object a}) {}
+
+  void set s(covariant Object s) {}
+  void operator +(covariant Object n) {}
+}
+
+class C extends A {
+  void m1(num a) {}
+  void m2([num a = 0]) {}
+  void m3({num a = 0}) {}
+  void m4({required num a}) {}
+
+  void set s(num n) {}
+  void operator +(num n) {}
+}
+
+main() {
+  print(C);
+}