#1198. Remove callable_objects_instantiation_* tests and add e<typeArgs> tests instead
diff --git a/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A01_t01.dart b/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A01_t01.dart
deleted file mode 100644
index 2ba9aa4..0000000
--- a/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A01_t01.dart
+++ /dev/null
@@ -1,30 +0,0 @@
-// 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 We do not allow implicit instantiation of callable objects. Given
-/// e<typeArgs> where e has a static type which is a class with a generic call
-/// method, we do not implicitly convert this to e.call<typeArgs>, like we would
-/// for a call like e<typeArgs>(args). You cannot type-instantiate function
-/// values, only call them, and here we treat "callable objects" like function
-/// values. You can write e.call<typeArgs> and treat call as a normal generic
-/// instance method.
-///
-/// @description Checks that in case of e<typeArgs> where e has a static type
-/// which is a class with a generic call method, is not implicitly convert
-/// this to e.call<typeArgs>
-/// @author sgrekhov@unipro.ru
-
-// SharedOptions=--enable-experiment=constructor-tearoffs
-
-import "../../Utils/expect.dart";
-
-class C<T extends num> {
- T call(T t) => t;
-}
-
-main() {
- var c = C<int>;
- Expect.isTrue(c is Type);
- Expect.equals("C<int>", c.toString());
-}
diff --git a/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A01_t02.dart b/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A01_t02.dart
deleted file mode 100644
index b1967aa..0000000
--- a/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A01_t02.dart
+++ /dev/null
@@ -1,32 +0,0 @@
-// 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 We do not allow implicit instantiation of callable objects. Given
-/// e<typeArgs> where e has a static type which is a class with a generic call
-/// method, we do not implicitly convert this to e.call<typeArgs>, like we would
-/// for a call like e<typeArgs>(args). You cannot type-instantiate function
-/// values, only call them, and here we treat "callable objects" like function
-/// values. You can write e.call<typeArgs> and treat call as a normal generic
-/// instance method.
-///
-/// @description Checks that in case of e<typeArgs> where e has a static type
-/// which is a class with a generic call method, is not implicitly convert
-/// this to e.call<typeArgs>
-/// @author sgrekhov@unipro.ru
-
-// SharedOptions=--enable-experiment=constructor-tearoffs
-
-import "../../Utils/expect.dart";
-
-class C<T extends num> {
- T call(T t) => t;
-}
-
-main() {
- var c = C<int>;
- c();
-//^
-// [analyzer] unspecified
-// [cfe] unspecified
-}
diff --git a/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A02_t01.dart b/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A02_t01.dart
deleted file mode 100644
index 4c8d998..0000000
--- a/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A02_t01.dart
+++ /dev/null
@@ -1,31 +0,0 @@
-// 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 We do not allow implicit instantiation of callable objects. Given
-/// e<typeArgs> where e has a static type which is a class with a generic call
-/// method, we do not implicitly convert this to e.call<typeArgs>, like we would
-/// for a call like e<typeArgs>(args). You cannot type-instantiate function
-/// values, only call them, and here we treat "callable objects" like function
-/// values. You can write e.call<typeArgs> and treat call as a normal generic
-/// instance method.
-///
-/// @description Checks that in case of e.call<typeArgs> call is treated as a
-/// normal generic instance method.
-/// @author sgrekhov@unipro.ru
-
-// SharedOptions=--enable-experiment=constructor-tearoffs
-
-import "../../Utils/expect.dart";
-
-typedef int Func(int i);
-
-class C {
- T call<T extends num>(T t) => t;
-}
-
-main() {
- var c = C().call<int>;
- Expect.isTrue(c is Func);
- Expect.equals(42, c(42));
-}
diff --git a/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A02_t02.dart b/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A02_t02.dart
deleted file mode 100644
index e11ceb2..0000000
--- a/LanguageFeatures/Constructor-tear-offs/callable_objects_instantiation_A02_t02.dart
+++ /dev/null
@@ -1,29 +0,0 @@
-// 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 We do not allow implicit instantiation of callable objects. Given
-/// e<typeArgs> where e has a static type which is a class with a generic call
-/// method, we do not implicitly convert this to e.call<typeArgs>, like we would
-/// for a call like e<typeArgs>(args). You cannot type-instantiate function
-/// values, only call them, and here we treat "callable objects" like function
-/// values. You can write e.call<typeArgs> and treat call as a normal generic
-/// instance method.
-///
-/// @description Checks that in case of e.call<typeArgs> call is treated as a
-/// normal generic instance method.
-/// @author sgrekhov@unipro.ru
-
-// SharedOptions=--enable-experiment=constructor-tearoffs
-
-class C {
- T call<T>(T t) => t;
-}
-
-main() {
- var c = C().call<int>;
- c("Lily was here");
-// ^^^^^^^^^^^^^^^
-// [analyzer] unspecified
-// [cfe] unspecified
-}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A01_t01.dart b/LanguageFeatures/Constructor-tear-offs/expression_A01_t01.dart
new file mode 100644
index 0000000..65352d4
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A01_t01.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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+///
+/// - If e denotes a generic class, mixin or type alias declaration (which means
+/// that e is an identifier, possibly a qualified identifier, which resolves to
+/// the class, mixin or type alias declaration), then e<typeArgs> is a type
+/// literal. If followed by .id then that id must denote a constructor, which
+/// can then be either torn off or invoked. If followed by == or != or any
+/// "stop-token", the expression evaluates to a Type object.
+///
+/// @description Checks that if in the expression of the form e<typeArgs> e
+/// denotes a class, mixin or type alias then e<typeArgs> is a type literal
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class C<T> {
+}
+
+typedef CAlias<T> = C<T>;
+
+mixin M<T> {}
+
+main() {
+ var c1 = C<int>;
+ Expect.isTrue(c1 is Type);
+ Expect.isFalse(c1 is C);
+ Expect.equals("C<int>", c1.toString());
+
+ var c2 = CAlias<int>;
+ Expect.isTrue(c2 is Type);
+ Expect.isFalse(c2 is C);
+ Expect.equals("C<int>", c2.toString());
+
+ var c3 = M<String>;
+ Expect.isTrue(c3 is Type);
+ Expect.isFalse(c3 is C);
+ Expect.equals("M<String>", c3.toString());
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A01_t02.dart b/LanguageFeatures/Constructor-tear-offs/expression_A01_t02.dart
new file mode 100644
index 0000000..095fd91
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A01_t02.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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+///
+/// - If e denotes a generic class, mixin or type alias declaration (which means
+/// that e is an identifier, possibly a qualified identifier, which resolves to
+/// the class, mixin or type alias declaration), then e<typeArgs> is a type
+/// literal. If followed by .id then that id must denote a constructor, which
+/// can then be either torn off or invoked. If followed by == or != or any
+/// "stop-token", the expression evaluates to a Type object.
+///
+/// @description Checks that if in the expression of the form e<typeArgs> e
+/// denotes a class and followed by .id then it denotes a constructor
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class C<T> {
+ C.id();
+}
+
+typedef CAlias<T> = C<T>;
+
+main() {
+ var c1 = C<int>.id;
+ Expect.isFalse(c1 is Type);
+ Expect.isTrue(c1 is C<int> Function());
+
+ var c2 = CAlias<int>.id;
+ Expect.isFalse(c2 is Type);
+ Expect.isTrue(c2 is C<int> Function());
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A01_t03.dart b/LanguageFeatures/Constructor-tear-offs/expression_A01_t03.dart
new file mode 100644
index 0000000..2ea1159
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A01_t03.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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+///
+/// - If e denotes a generic class, mixin or type alias declaration (which means
+/// that e is an identifier, possibly a qualified identifier, which resolves to
+/// the class, mixin or type alias declaration), then e<typeArgs> is a type
+/// literal. If followed by .id then that id must denote a constructor, which
+/// can then be either torn off or invoked. If followed by == or != or any
+/// "stop-token", the expression evaluates to a Type object.
+///
+/// @description Checks that if in the expression of the form e<typeArgs> e
+/// denotes a class and followed by .id then it must be a constructor
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+class C<T> {
+ void id() {}
+}
+
+typedef CAlias<T> = C<T>;
+
+main() {
+ var c1 = C<int>.id;
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ var c2 = CAlias<int>.id;
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A01_t04.dart b/LanguageFeatures/Constructor-tear-offs/expression_A01_t04.dart
new file mode 100644
index 0000000..8530c74
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A01_t04.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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+///
+/// - If e denotes a generic class, mixin or type alias declaration (which means
+/// that e is an identifier, possibly a qualified identifier, which resolves to
+/// the class, mixin or type alias declaration), then e<typeArgs> is a type
+/// literal. If followed by .id then that id must denote a constructor, which
+/// can then be either torn off or invoked. If followed by == or != or any
+/// "stop-token", the expression evaluates to a Type object.
+///
+/// @description Checks that it is a compile error to tear off a static member
+/// of an instantiated generic class
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+class C<T> {
+ static void foo1<X>(X x) {}
+}
+
+typedef CAlias<T> = C<T>;
+
+main() {
+ var c1 = C<int>.foo1<int>;
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ var c2 = CAlias<int>.foo1<int>;
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A01_t05.dart b/LanguageFeatures/Constructor-tear-offs/expression_A01_t05.dart
new file mode 100644
index 0000000..0cb22a5
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A01_t05.dart
@@ -0,0 +1,50 @@
+// 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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+///
+/// - If e denotes a generic class, mixin or type alias declaration (which means
+/// that e is an identifier, possibly a qualified identifier, which resolves to
+/// the class, mixin or type alias declaration), then e<typeArgs> is a type
+/// literal. If followed by .id then that id must denote a constructor, which
+/// can then be either torn off or invoked. If followed by == or != or any
+/// "stop-token", the expression evaluates to a Type object.
+///
+/// @description Checks that if in the expression of the form e<typeArgs> e
+/// denotes a class, mixin or type alias then e<typeArgs> is a type literal.
+/// Test the case when class denoted by e gas a 'call' method
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class C<T> {
+ void call() {}
+}
+
+typedef CAlias<T> = C<T>;
+
+mixin M<T> {
+ void call() {}
+}
+
+main() {
+ var c1 = C<int>;
+ Expect.isTrue(c1 is Type);
+ Expect.isFalse(c1 is C);
+ Expect.equals("C<int>", c1.toString());
+
+ var c2 = CAlias<int>;
+ Expect.isTrue(c2 is Type);
+ Expect.isFalse(c2 is C);
+ Expect.equals("C<int>", c2.toString());
+
+ var c3 = M<String>;
+ Expect.isTrue(c3 is Type);
+ Expect.isFalse(c3 is C);
+ Expect.equals("M<String>", c3.toString());
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A02_t01.dart b/LanguageFeatures/Constructor-tear-offs/expression_A02_t01.dart
new file mode 100644
index 0000000..dba7793
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A02_t01.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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+/// ...
+/// - If e denotes a generic top-level, static or local function declaration
+/// (again e is an identifier or qualified identifier), that declaration must be
+/// a generic function declaration, and then e<typeArgs> performs an explicitly
+/// instantiated function tear-off, which works just like the current implicitly
+/// instantiated function tear-off except that the types are provided instead of
+/// inferred.
+///
+/// @description Checks that if e denotes a generic top-level, static or local
+/// function declaration then that declaration must be a generic function
+/// declaration, and then e<typeArgs> performs an explicitly instantiated
+/// function tear-off
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class C {
+ static void foo1<X>(X x) {}
+}
+
+typedef CAlias = C;
+
+void foo2<T>(T t) {}
+
+main() {
+ void foo3<T>(T t) {}
+
+ var c1 = C.foo1<int>;
+ Expect.isFalse(c1 is Type);
+ Expect.isTrue(c1 is void Function(int));
+
+ var c2 = CAlias.foo1<String>;
+ Expect.isFalse(c2 is Type);
+ Expect.isTrue(c2 is void Function(String));
+
+ var c3 = foo2<bool>;
+ Expect.isFalse(c3 is Type);
+ Expect.isTrue(c3 is void Function(bool));
+
+ var c4 = foo3<double>;
+ Expect.isFalse(c4 is Type);
+ Expect.isTrue(c4 is void Function(double));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A03_t01.dart b/LanguageFeatures/Constructor-tear-offs/expression_A03_t01.dart
new file mode 100644
index 0000000..bd56788
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A03_t01.dart
@@ -0,0 +1,37 @@
+// 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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+/// ...
+/// - If e denotes a generic instance method (e has the form r.name and r has a
+/// static type for which name is a generic interface method), then e<typeArgs>
+/// performs an explicitly instantiated method tear-off, which works just like
+/// the current implicitly instantiated method tear-off except that the types
+/// are provided instead of inferred.
+///
+/// @description Checks that if e denotes a generic instance method then then
+/// e<typeArgs> performs an explicitly instantiated method tear-off
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class C {
+ void foo1<X>(X x) {}
+}
+
+typedef CAlias = C;
+
+main() {
+ var c1 = C().foo1<int>;
+ Expect.isFalse(c1 is Type);
+ Expect.isTrue(c1 is void Function(int));
+
+ var c2 = CAlias().foo1<String>;
+ Expect.isFalse(c2 is Type);
+ Expect.isTrue(c2 is void Function(String));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A03_t02.dart b/LanguageFeatures/Constructor-tear-offs/expression_A03_t02.dart
new file mode 100644
index 0000000..92705e6
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A03_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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+/// ...
+/// - If e denotes a generic instance method (e has the form r.name and r has a
+/// static type for which name is a generic interface method), then e<typeArgs>
+/// performs an explicitly instantiated method tear-off, which works just like
+/// the current implicitly instantiated method tear-off except that the types
+/// are provided instead of inferred.
+///
+/// @description Checks that if e denotes a generic instance method then then
+/// e<typeArgs> performs an explicitly instantiated method tear-off
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class A {}
+
+mixin M {
+ void foo1<X>(X x) {}
+}
+
+class C = A with M;
+
+extension on C {
+ void bar<X>(X x) {}
+}
+
+main() {
+ var c1 = C().foo1<int>;
+ Expect.isFalse(c1 is Type);
+ Expect.isTrue(c1 is void Function(int));
+
+ var c2 = C().bar<int>;
+ Expect.isFalse(c2 is Type);
+ Expect.isTrue(c2 is void Function(int));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A04_t01.dart b/LanguageFeatures/Constructor-tear-offs/expression_A04_t01.dart
new file mode 100644
index 0000000..191e534
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A04_t01.dart
@@ -0,0 +1,37 @@
+// 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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+/// ...
+/// - If e has a static type which is a generic callable object type (a
+/// non-function type with a generic method named call), then e<typeArgs> is
+/// equivalent to the instantiated method-tear off e.call<typeArgs>.
+///
+/// @description Checks that if e denotes a generic instance method then then
+/// e<typeArgs> performs an explicitly instantiated method tear-off
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class C {
+ T call<T>(T t) => t;
+}
+
+typedef CAlias = C;
+
+main() {
+ var c1 = C()<int>;
+ Expect.isFalse(c1 is Type);
+ Expect.isTrue(c1 is int Function(int));
+ Expect.equals(c1, C().call<int>);
+
+ var c2 = CAlias()<int>;
+ Expect.isFalse(c2 is Type);
+ Expect.isTrue(c2 is int Function(int));
+ Expect.equals(c2, CAlias().call<int>);
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A04_t02.dart b/LanguageFeatures/Constructor-tear-offs/expression_A04_t02.dart
new file mode 100644
index 0000000..d116bfc
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A04_t02.dart
@@ -0,0 +1,34 @@
+// 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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+/// ...
+/// - If e has a static type which is a generic callable object type (a
+/// non-function type with a generic method named call), then e<typeArgs> is
+/// equivalent to the instantiated method-tear off e.call<typeArgs>.
+///
+/// @description Checks that if e denotes a generic instance method then then
+/// e<typeArgs> performs an explicitly instantiated method tear-off
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class A {}
+
+mixin M {
+ T call<T>(T t) => t;
+}
+
+class C = A with M;
+
+main() {
+ var c1 = C()<int>;
+ Expect.isFalse(c1 is Type);
+ Expect.isTrue(c1 is int Function(int));
+ Expect.equals(c1, C().call<int>);
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/expression_A04_t03.dart b/LanguageFeatures/Constructor-tear-offs/expression_A04_t03.dart
new file mode 100644
index 0000000..b7aad42
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/expression_A04_t03.dart
@@ -0,0 +1,32 @@
+// 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 For an expression of the form e<typeArgs>, which is not followed
+/// by an argument list (that would turn it into a generic function invocation),
+/// the meaning of e<typeArgs> depends on the expression e:
+/// ...
+/// - If e has a static type which is a generic callable object type (a
+/// non-function type with a generic method named call), then e<typeArgs> is
+/// equivalent to the instantiated method-tear off e.call<typeArgs>.
+///
+/// @description Checks that if e denotes a generic instance method then then
+/// e<typeArgs> performs an explicitly instantiated method tear-off
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+class C {}
+
+extension on C {
+ T call<T>(T t) => t;
+}
+
+main() {
+ var c1 = C()<int>;
+ Expect.isFalse(c1 is Type);
+ Expect.isTrue(c1 is int Function(int));
+ Expect.equals(c1, C().call<int>);
+}
