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
+}