Issue #1087: New Constructor Tear Offs tests added
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t01.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t01.dart
index 275e95d..c1128d5 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t01.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t01.dart
@@ -28,6 +28,6 @@
main() {
var v = C.constr ;
- v(1);
- Expect.isTrue(C.called);
+ C c = v(1);
+ Expect.isTrue(c.called);
}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t02.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t02.dart
index 881a730..6da519d 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t02.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t02.dart
@@ -29,6 +29,6 @@
main() {
var v = C.constr;
- v(1);
- Expect.isTrue(C.called);
+ C c = v(1);
+ Expect.isTrue(c.called);
}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t03.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t03.dart
index b91597f..81f1892 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A01_t03.dart
@@ -29,6 +29,6 @@
main() {
var v = C<int>.constr;
- v(1);
+ C c = v(1);
Expect.isTrue(C.called);
}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A02_t01.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A02_t01.dart
index 26c94f7..5120625 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A02_t01.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A02_t01.dart
@@ -16,17 +16,11 @@
import "../../Utils/expect.dart";
class C {
- static bool called = false;
-
C() {}
-
- C.constr() {
- called = true;
- }
+ C.constr() {}
}
main() {
- Expect.isTrue(C.constr@tearoff is C Function());
- C c1 = C.constr@tearoff();
- Expect.isTrue(C.called);
+ Expect.isTrue(C.constr is C Function());
+ Expect.isTrue(C.new is C Function());
}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A02_t02.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A02_t02.dart
index 2518881..0483602 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A02_t02.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A02_t02.dart
@@ -16,21 +16,17 @@
import "../../Utils/expect.dart";
class C<T> {
- static int called = 0;
-
C() {}
-
- C.constr(expected) {
- Expect.equals(expected, T);
- called++;
- }
+ C.constr(T t) {}
}
main() {
- Expect.isTrue(C.constr@tearoff is C Function<dynamic>(dynamic));
- C c = C.constr@tearoff(dynamic);
- Expect.equals(1, C.called);
+ Expect.isTrue(C.constr is C Function<dynamic>(dynamic));
+ Expect.isTrue(C.new is C Function<dynamic>(dynamic));
- C c1 = C<int>.constr@tearoff(int);
- Expect.equals(2, C.called);
+ Expect.isTrue(C<int>.constr is C Function<int>(int));
+ Expect.isTrue(C<int>.new is C Function<int>());
+
+ Expect.isTrue(C.constr<int> is C Function<int>(int));
+ Expect.isTrue(C.new<int> is C Function<int>());
}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t01.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t01.dart
index f9721b7..23440c7 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t01.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t01.dart
@@ -16,18 +16,18 @@
}
main() {
- var v = C<int>.constr;
-// ^
+ var v1 = C<int>.constr;
+// ^
// [analyzer] unspecified
// [cfe] unspecified
- var v = C<dynamic>.constr;
-// ^
+ var v2 = C<dynamic>.constr;
+// ^
// [analyzer] unspecified
// [cfe] unspecified
- var v = C<String, int, int>.constr;
-// ^
+ var v3 = C<String, int, int>.constr;
+// ^
// [analyzer] unspecified
// [cfe] unspecified
}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t02.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t02.dart
index 09038c4..e6dea21 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t02.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t02.dart
@@ -28,22 +28,22 @@
main() {
var v1 = C.constr;
- v1(dynamic);
- Expect.equals(1, C.called);
+ C c1 = v1(dynamic);
+ Expect.equals(1, c1.called);
var v2 = C<dynamic>.constr;
- v2(dynamic);
- Expect.equals(2, C.called);
+ C c2 = v2(dynamic);
+ Expect.equals(2, c2.called);
var v3 = (C<dynamic>).constr;
- v3(dynamic);
- Expect.equals(3, C.called);
+ C c3 = v3(dynamic);
+ Expect.equals(3, c3.called);
- var v3 = (C<int>).constr;
- v3(int);
- Expect.equals(3, C.called);
+ var v4 = (C<int>).constr;
+ C<int> c4 = v4(int);
+ Expect.equals(4, c4.called);
- var v3 = (C<num>).constr;
- v3<int>(int);
- Expect.equals(3, C.called);
+ var v5 = (C<num>).constr;
+ C c5 = v5<int>(int);
+ Expect.equals(5, c5.called);
}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t03.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t03.dart
new file mode 100644
index 0000000..2bc0358
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t03.dart
@@ -0,0 +1,47 @@
+// Copyright (c) 2021, 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 If [C] is not generic, then [<typeParams>] and [<typeArgs>] are
+/// omitted. Otherwise <typeParams> are exactly the same type parameters as
+/// those of the class declaration of [C] (including bounds), and [<typeArgs>]
+/// applies those type parameter variables directly as type arguments to [C].
+///
+/// @description Checks that for generic class <typeParams> are exactly the same
+/// type parameters as those of the class declaration of [C] (including bounds),
+/// and [<typeArgs>] applies those type parameter variables directly as type
+/// arguments to [C] - test case with the several type parameters.
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C<T1, T2 extends num, T3 extends String> {
+ static int called = 0;
+
+ C() {}
+
+ C.constr(exp1, exp2, exp3) {
+ Expect.equals(exp1, T1);
+ Expect.equals(exp2, T2);
+ Expect.equals(exp3, T3);
+ called++;
+ }
+}
+
+main() {
+ var v1 = C.constr;
+ C c1 = v1(dynamic, num, String);
+ Expect.equals(1, c1.called);
+
+ var v2 = C<dynamic, num, String>.constr;
+ C c2 = v2(dynamic, num, String);
+ Expect.equals(2, c2.called);
+
+ var v3 = C<dynamic, int, String>.constr;
+ C c3 = v3(dynamic, int, String);
+ Expect.equals(3, c3.called);
+
+ var v4 = (C<dynamic, int, String>).constr;
+ C<dynamic, int, String> c4 = v4(int);
+ Expect.equals(4, c4.called);
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t04.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t04.dart
new file mode 100644
index 0000000..a62d15b
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t04.dart
@@ -0,0 +1,35 @@
+// Copyright (c) 2021, 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 If [C] is not generic, then [<typeParams>] and [<typeArgs>] are
+/// omitted. Otherwise <typeParams> are exactly the same type parameters as
+/// those of the class declaration of [C] (including bounds), and [<typeArgs>]
+/// applies those type parameter variables directly as type arguments to [C].
+///
+/// @description Checks that for generic class <typeParams> are exactly the same
+/// type parameters as those of the class declaration of [C] (including bounds),
+/// and [<typeArgs>] applies those type parameter variables directly as type
+/// arguments to [C] - test case with the different type parameter numbers.
+/// @author iarkh@unipro.ru
+
+class C<T1, T2 extends num, T3 extends String> {
+ C.constr(exp1, exp2, exp3) {}
+}
+
+main() {
+ C<dynamic>.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C<dynamic, num>.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C<dynamic, num, String, dynamic>.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t05.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t05.dart
new file mode 100644
index 0000000..d0b935c
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t05.dart
@@ -0,0 +1,35 @@
+// Copyright (c) 2021, 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 If [C] is not generic, then [<typeParams>] and [<typeArgs>] are
+/// omitted. Otherwise <typeParams> are exactly the same type parameters as
+/// those of the class declaration of [C] (including bounds), and [<typeArgs>]
+/// applies those type parameter variables directly as type arguments to [C].
+///
+/// @description Checks that for generic class <typeParams> are exactly the same
+/// type parameters as those of the class declaration of [C] (including bounds),
+/// and [<typeArgs>] applies those type parameter variables directly as type
+/// arguments to [C] - test incorrect type parameters.
+/// @author iarkh@unipro.ru
+
+class C<T1 extends int> {
+ C.constr(exp1, exp2, exp3) {}
+}
+
+main() {
+ C<String>.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C<num>.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C<Null>.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t06.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t06.dart
new file mode 100644
index 0000000..8e9718a
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A03_t06.dart
@@ -0,0 +1,26 @@
+// Copyright (c) 2021, 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 If [C] is not generic, then [<typeParams>] and [<typeArgs>] are
+/// omitted. Otherwise <typeParams> are exactly the same type parameters as
+/// those of the class declaration of [C] (including bounds), and [<typeArgs>]
+/// applies those type parameter variables directly as type arguments to [C].
+///
+/// @description Checks that for generic class <typeParams> are exactly the same
+/// type parameters as those of the class declaration of [C] (including bounds),
+/// and [<typeArgs>] applies those type parameter variables directly as type
+/// arguments to [C] - test incorrect type arguments.
+/// @author iarkh@unipro.ru
+
+class C<T> {
+ C.constr() {}
+}
+
+main() {
+ var v = C<String>.constr;
+ v<int>();
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t01.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t01.dart
new file mode 100644
index 0000000..13d6cd9
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t01.dart
@@ -0,0 +1,47 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list.
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ C.constr1() {}
+ C.constr2(int i) {}
+ C.constr3(i) {}
+ C.constr4(int i, String j, List<int> l) {}
+ C.constr5(i, j, k) {}
+}
+
+main() {
+ C Function() v1 = C.constr1;
+ Expect.isTrue(v1 is C Function());
+ v1();
+
+ var v2 = C.constr2;
+ Expect.isTrue(v2 is C Function(int));
+ v2(14);
+
+ var v3 = C.constr3;
+ Expect.isTrue(v3 is C Function(dynamic));
+ v3(0);
+ v3(null);
+
+ var v4 = C.constr4;
+ Expect.isTrue(v4 is C Function(int, String, List<int>));
+ v4(1, "123", [1, 2, 3]);
+
+ var v5 = C.constr5;
+ Expect.isTrue(v5 is C Function(dynamic, dynamic, dynamic));
+ v5(1, "123", [1, 2, 3]);
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t02.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t02.dart
new file mode 100644
index 0000000..62156a2
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t02.dart
@@ -0,0 +1,43 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that [params] is exactly the same parameter
+/// list test constructor without arguments.
+/// @author iarkh@unipro.ru
+
+class C {
+ C.constr() {}
+}
+
+main() {
+ C Function() v1 = C.constr;
+
+ C Function(int) v2 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(dynamic) v3 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function([int]) v4 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function({String s = "12345"}) v5 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t03.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t03.dart
new file mode 100644
index 0000000..bf7f5ba
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t03.dart
@@ -0,0 +1,63 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that [params] is exactly the same parameter
+/// list - test case with one [int] argument.
+/// @author iarkh@unipro.ru
+
+class C {
+ C.constr(num i) {}
+}
+
+main() {
+ C Function(num) v = C.constr;
+
+ C Function(int) v1 = C.constr;
+
+ C Function() v2 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(dynamic) v3 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(Object) v4 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(Object?) v5 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(String) v6 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(num, int) v7 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(Never) v8 = C.constr;
+
+ C Function(Null) v9 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t04.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t04.dart
new file mode 100644
index 0000000..0121c72
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t04.dart
@@ -0,0 +1,33 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that [params] is exactly the same parameter
+/// list - test case with one [dynamic] argument.
+/// @author iarkh@unipro.ru
+
+class C {
+ C.constr(i) {}
+}
+
+main() {
+ C Function(dynamic) v1 = C.constr;
+
+ C Function() v2 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(dynamic, dynamic) v3 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t05.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t05.dart
new file mode 100644
index 0000000..f964f80
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t05.dart
@@ -0,0 +1,48 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that [params] is exactly the same parameter
+/// list - test case with several argument.
+/// @author iarkh@unipro.ru
+
+class C {
+ C.constr(int i, String j, List<int> l) {}
+}
+
+main() {
+ C Function(int, String, List<int>) v1 = C.constr;
+
+ C Function(int) v2 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(int, String) v3 = C.constr3;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(int, String, List) v4 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(int, String, List<int>, List) v5 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(dynamic, dynamic, dynamic) v6 = C.constr;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t06.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t06.dart
new file mode 100644
index 0000000..19f6838
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t06.dart
@@ -0,0 +1,33 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that initializing formals are represented by normal
+/// parameters with the same name and type.
+
+import "../../Utils/expect.dart";
+
+class C {
+ int x;
+ dynamic y;
+ C.name(this.x, this.y);
+}
+
+dynamic d = 0.5;
+
+main() {
+ var v = C.name;
+ Expect.isTrue(v is C Function(int x, dynamic y));
+ v(42, "I am strong");
+
+ Expect.throws(() { v(d, "test"); });
+ Expect.throws(() { v(1, d); });
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t07.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t07.dart
new file mode 100644
index 0000000..903ace8
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t07.dart
@@ -0,0 +1,39 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that initializing formals are represented by
+/// normal parameters with the same name and type.
+
+class C {
+ int x;
+ dynamic y;
+ C.name(this.x, this.y);
+}
+
+main() {
+ C Function(int x, dynamic y) f1 = C.name;
+
+ C Function(num x, dynamic y) f2 = C.name;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function() f3 = C.name;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ C Function(int, dynamic, void) f4 = C.name;
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t08.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t08.dart
new file mode 100644
index 0000000..c3fe4be
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t08.dart
@@ -0,0 +1,44 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that initializing formals are represented by
+/// normal parameters with the same name and type.
+
+class C {
+ int x;
+ dynamic y;
+ C.name(this.x, this.y);
+}
+
+main() {
+ var v = C.name;
+
+ v();
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(0, 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(0);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(0, "incorrect line", 12);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t09.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t09.dart
new file mode 100644
index 0000000..f01e99a
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t09.dart
@@ -0,0 +1,52 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list - test
+/// named parameters
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ int ii = 0;
+ int? jj = 0;
+ String ss = "";
+
+ C.constr(int i, {int? j, String s = "testme"}) {
+ ii = i;
+ jj = j;
+ ss = s;
+ }
+
+ void check(exp1, exp2, exp3) {
+ Expect.equals(exp1, ii);
+ Expect.equals(exp2, jj);
+ Expect.equals(exp3, ss);
+ }
+}
+
+main() {
+ var v = C.constr;
+ Expect.isTrue(v is C Function(int i, {int? j, String s}));
+
+ C c1 = v(1);
+ c1.check(1, null, "testme");
+
+ C c2 = v(12, j:90);
+ c2.check(12, 90, "testme");
+
+ C c3 = v(12, s: "stop");
+ c3.check(12, null, "stop");
+
+ C c4 = v(12, s: "", j:90);
+ c2.check(12, 90, "");
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t10.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t10.dart
new file mode 100644
index 0000000..7293a54
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t10.dart
@@ -0,0 +1,48 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that initializing formals are represented by normal
+/// parameters with the same name and type - test named parameters.
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ int i = 0;
+ int? j = 0;
+ String s = "";
+
+ C.constr(this.i, {this.j, this.s = "default"});
+
+ void check(exp1, exp2, exp3) {
+ Expect.equals(exp1, i);
+ Expect.equals(exp2, j);
+ Expect.equals(exp3, s);
+ }
+}
+
+main() {
+ var v = C.constr;
+ Expect.isTrue(v is C Function(int i, {int? j, String s}));
+
+ C c1 = v(1);
+ c1.check(1, null, "testme");
+
+ C c2 = v(12, j:90);
+ c2.check(12, 90, "testme");
+
+ C c3 = v(12, s: "stop");
+ c3.check(12, null, "stop");
+
+ C c4 = v(12, s: "", j:90);
+ c2.check(12, 90, "");
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t11.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t11.dart
new file mode 100644
index 0000000..24800d7
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t11.dart
@@ -0,0 +1,44 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list - test
+/// incorrect named arguments dynamically.
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ int ii = 0;
+ int? jj = 0;
+ String ss = "";
+
+ C.constr(int i, {int? j, String s = "testme"}) {
+ ii = i;
+ jj = j;
+ ss = s;
+ }
+
+ void check(exp1, exp2, exp3) {
+ Expect.equals(exp1, ii);
+ Expect.equals(exp2, jj);
+ Expect.equals(exp3, ss);
+ }
+}
+
+dynamic d = 1.5;
+
+main() {
+ var v = C.constr;
+
+ Expect.throws(() { v(1, j: d); });
+ Expect.throws(() { v(1, s: d); });
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t12.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t12.dart
new file mode 100644
index 0000000..41f8116
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t12.dart
@@ -0,0 +1,48 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list - test
+/// incorrect named arguments statically.
+/// @author iarkh@unipro.ru
+
+class C {
+ C.constr({int? j, String s = "testme"}) {}
+}
+
+main() {
+ var v = C.constr;
+
+ v(incorrect: 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(j: "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(s: null);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(1, "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t13.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t13.dart
new file mode 100644
index 0000000..ae56e3a
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t13.dart
@@ -0,0 +1,51 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that initializing formals are represented by
+/// normal parameters with the same name and type - test named parameters.
+/// @author iarkh@unipro.ru
+
+class C {
+ int? j = 0;
+ String s = "";
+
+ C.constr({this.j, this.s = "default"});
+}
+
+main() {
+ var v = C.constr;
+
+ v(incorrect: 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(j: "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(s: null);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(1, "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t14.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t14.dart
new file mode 100644
index 0000000..8e3ce59
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t14.dart
@@ -0,0 +1,52 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list - test
+/// additional parameters
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ int ii = 0;
+ int? jj = 0;
+ String ss = "";
+
+ C.constr(int i, [int? j, String s = "testme"]) {
+ ii = i;
+ jj = j;
+ ss = s;
+ }
+
+ void check(exp1, exp2, exp3) {
+ Expect.equals(exp1, ii);
+ Expect.equals(exp2, jj);
+ Expect.equals(exp3, ss);
+ }
+}
+
+main() {
+ var v = C.constr;
+ Expect.isTrue(v is C Function(int i, {int? j, String s}));
+
+ C c1 = v(1);
+ c1.check(1, null, "testme");
+
+ C c2 = v(12, 90);
+ c2.check(12, 90, "testme");
+
+ C c3 = v(12, null, "stop");
+ c3.check(12, null, "stop");
+
+ C c4 = v(12, 90, "");
+ c2.check(12, 90, "");
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t15.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t15.dart
new file mode 100644
index 0000000..e2cdb26
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t15.dart
@@ -0,0 +1,48 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that initializing formals are represented by normal
+/// parameters with the same name and type - test additional parameters.
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ int i = 0;
+ int? j = 0;
+ String s = "";
+
+ C.constr(this.i, [this.j, this.s = "default"]);
+
+ void check(exp1, exp2, exp3) {
+ Expect.equals(exp1, i);
+ Expect.equals(exp2, j);
+ Expect.equals(exp3, s);
+ }
+}
+
+main() {
+ var v = C.constr;
+ Expect.isTrue(v is C Function(int i, [int? j, String s]));
+
+ C c1 = v(1);
+ c1.check(1, null, "testme");
+
+ C c2 = v(12, 90);
+ c2.check(12, 90, "testme");
+
+ C c3 = v(12, "stop");
+ c3.check(12, null, "stop");
+
+ C c4 = v(12, 90, "");
+ c2.check(12, 90, "");
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t16.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t16.dart
new file mode 100644
index 0000000..7b06c2a
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t16.dart
@@ -0,0 +1,44 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list - test
+/// incorrect additional arguments dynamically.
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ int ii = 0;
+ int? jj = 0;
+ String ss = "";
+
+ C.constr(int i, [int? j, String s = "testme"]) {
+ ii = i;
+ jj = j;
+ ss = s;
+ }
+
+ void check(exp1, exp2, exp3) {
+ Expect.equals(exp1, ii);
+ Expect.equals(exp2, jj);
+ Expect.equals(exp3, ss);
+ }
+}
+
+dynamic d = 1.5;
+
+main() {
+ var v = C.constr;
+
+ Expect.throws(() { v(1, d); });
+ Expect.throws(() { v(1, 2, d); });
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t17.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t17.dart
new file mode 100644
index 0000000..0199f6c
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t17.dart
@@ -0,0 +1,43 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list - test
+/// incorrect additional arguments statically.
+/// @author iarkh@unipro.ru
+
+class C {
+ C.constr([int? j, String s = "testme"]) {}
+}
+
+main() {
+ var v = C.constr;
+
+ v(incorrect: 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v("");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(null, 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v("", "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t18.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t18.dart
new file mode 100644
index 0000000..66f9eda
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t18.dart
@@ -0,0 +1,46 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that initializing formals are represented by
+/// normal parameters with the same name and type - test additional parameters.
+/// @author iarkh@unipro.ru
+
+class C {
+ int? j = 0;
+ String s = "";
+
+ C.constr([this.j, this.s = "default"]);
+}
+
+main() {
+ var v = C.constr;
+
+ v(incorrect: 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v("");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(null, 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v("", "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t19.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t19.dart
new file mode 100644
index 0000000..893844a
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t19.dart
@@ -0,0 +1,38 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list - test
+/// required named parameter.
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ int? ii;
+
+ C.constr({required int i}) {
+ ii = i;
+ }
+}
+
+dynamic d = 1.1;
+
+main() {
+ var v = C.constr;
+ Expect.isTrue(v is C Function({ required int i }));
+
+ C c1 = v(i: 1);
+ Expect.equals(1, c1.ii);
+
+ Expect.throws(() { v(i: d); });
+ Expect.throws(() { v(i: null as dynamic); });
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t20.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t20.dart
new file mode 100644
index 0000000..64b2bf0
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t20.dart
@@ -0,0 +1,35 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that initializing formals are represented by normal
+/// parameters with the same name and type - test required named parameter.
+/// @author iarkh@unipro.ru
+
+import "../../Utils/expect.dart";
+
+class C {
+ int i = 0;
+ C.constr({required this.i});
+}
+
+dynamic d = 1.1;
+
+main() {
+ var v = C.constr;
+ Expect.isTrue(v is C Function({ required int i }));
+
+ C c1 = v(i: 1);
+ Expect.equals(1, c1.i);
+
+ Expect.throws(() { v(i: d); });
+ Expect.throws(() { v(i: null as dynamic); });
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t21.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t21.dart
new file mode 100644
index 0000000..0a59000
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t21.dart
@@ -0,0 +1,48 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks that [params] is exactly the same parameter list - test
+/// incorrect required named arguments statically.
+/// @author iarkh@unipro.ru
+
+class C {
+ C.constr({required int i}) {}
+}
+
+main() {
+ var v = C.constr;
+
+ v(incorrect: 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v();
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(i: null);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v("String");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(1, "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t22.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t22.dart
new file mode 100644
index 0000000..085f95e
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A04_t22.dart
@@ -0,0 +1,53 @@
+// Copyright (c) 2021, 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 Similarly, [params] is almost exactly the same parameter list
+/// as the constructor [C.name], with the one exception that initializing
+/// formals are represented by normal parameters with the same name and type.
+/// All remaining properties of the parameters are the same as for the
+/// corresponding constructor parameter, including any default values, and
+/// [args] is an argument list passing those parameters to [C.name] directly as
+/// they are received.
+///
+/// @description Checks statically that initializing formals are represented by
+/// normal parameters with the same name and type - test required named
+/// parameter.
+/// @author iarkh@unipro.ru
+
+class C {
+ int? i;
+
+ C.constr({required this.i});
+}
+
+main() {
+ var v = C.constr;
+
+ v();
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(incorrect: 1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(i: "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(i: null);
+
+ v("String here");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ v(1, "");
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
