#1087. Added more tests for resolving ambiguities
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t04.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t04.dart
new file mode 100644
index 0000000..a12b16c
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t04.dart
@@ -0,0 +1,54 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks disambiguate by '++' token. Test that a<b, c>++ is
+/// parsed as (a<b, c>)++
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+void f(x, [y]) {}
+
+main() {
+ int a = 1;
+ int b = 2;
+ int c = 3;
+
+ f(a<b,
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c>++);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t05.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t05.dart
new file mode 100644
index 0000000..0dd8cfe
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t05.dart
@@ -0,0 +1,59 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks disambiguate by '++' token. Test that a<b, c>++ is
+/// parsed as (a<b, c>)++. Test generic function tear-off
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String a<T1, T2>(int x) {
+ return "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Function {
+ Function operator+ (int i) => () {};
+}
+
+main() {
+ a<b,
+//^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c>++;
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t06.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t06.dart
new file mode 100644
index 0000000..24c5767
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A19_t06.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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks disambiguate by '++' token. Test that a<b, c>++ is
+/// parsed as (a<b, c>)++. Test constructor tear-off
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+class a<T1, T2> {
+ int x;
+ a(this.x);
+
+ @override
+ String toString() => "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Type {
+ Type operator+ (int i) => a<b, c>;
+}
+
+main() {
+ a<b,
+//^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c>++;
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t01.dart
new file mode 100644
index 0000000..cf861c3
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t01.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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '-' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+import "../../Utils/expect.dart";
+
+String f(a, [b]) => "$a, $b";
+
+main() {
+ int a = 1;
+ int b = 2;
+ int c = 3;
+ int d = 4;
+
+ Expect.equals("true, true", f(a < b, c > -d));
+ Expect.equals("true, true", f(a < b, c > -42));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t02.dart
new file mode 100644
index 0000000..a767b6e
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t02.dart
@@ -0,0 +1,72 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '-' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String f(a, [b]) => "$a, $b";
+
+String a<T1, T2>(int x) {
+ return "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Function {
+ int operator- (int index) => index;
+}
+
+main() {
+ int d = 42;
+ f(a < b,
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c > -d);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ f(a < b,
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c > -42);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t03.dart
new file mode 100644
index 0000000..c9e3cce
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t03.dart
@@ -0,0 +1,62 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '-' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+import "../../Utils/expect.dart";
+
+String f(a, [b]) => "$a, $b";
+
+String a<T1, T2>(int x) {
+ return "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Function {
+ bool operator< (Type t) => true;
+}
+
+extension on Type {
+ int operator>(int i) => i;
+}
+
+main() {
+ int d = 42;
+ Expect.equals("true, -42", f(a < b, c > -d));
+ Expect.equals("true, -42", f(a < b, c > -42));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t04.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t04.dart
new file mode 100644
index 0000000..18f58f9
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t04.dart
@@ -0,0 +1,75 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '-' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String f(a, [b]) => "$a, $b";
+
+class a<T1, T2> {
+ int x;
+ a(this.x);
+
+ @override
+ String toString() => "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Type {
+ int operator- (int index) => index;
+}
+main() {
+ int d = 42;
+ f(a < b,
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c > -d);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ f(a < b,
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c > -42);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t05.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t05.dart
new file mode 100644
index 0000000..87bf577
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t05.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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '-' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+import "../../Utils/expect.dart";
+
+String f(a, [b]) => "$a, $b";
+
+class a<T1, T2> {
+ int x;
+ a(this.x);
+
+ @override
+ String toString() => "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Type {
+ bool operator< (Type t) => true;
+ int operator> (int i) => i;
+}
+
+main() {
+ int d = 42;
+ Expect.equals("true, -42", f(a < b, c > -d));
+ Expect.equals("true, -42", f(a < b, c > -42));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t06.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t06.dart
new file mode 100644
index 0000000..289a5cc
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t06.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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '--' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+import "../../Utils/expect.dart";
+
+String f(a, [b]) => "$a, $b";
+
+main() {
+ int a = 1;
+ int b = 2;
+ int c = 3;
+ int d = 4;
+
+ Expect.equals("true, false", f(a < b, c > --d));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t07.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t07.dart
new file mode 100644
index 0000000..8590ca6
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t07.dart
@@ -0,0 +1,59 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '-' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String f(a, [b]) => "$a, $b";
+
+String a<T1, T2>(int x) {
+ return "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+main() {
+ int d = 42;
+ f(a < b,
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c > --d);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t08.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t08.dart
new file mode 100644
index 0000000..60fe3fb
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t08.dart
@@ -0,0 +1,61 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '--' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+import "../../Utils/expect.dart";
+
+String f(a, [b]) => "$a, $b";
+
+String a<T1, T2>(int x) {
+ return "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Function {
+ bool operator< (Type t) => true;
+}
+
+extension on Type {
+ int operator>(int i) => i;
+}
+
+main() {
+ int d = 42;
+ Expect.equals("true, 41", f(a < b, c > --d));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t09.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t09.dart
new file mode 100644
index 0000000..2b11c50
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t09.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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '--' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String f(a, [b]) => "$a, $b";
+
+class a<T1, T2> {
+ int x;
+ a(this.x);
+
+ @override
+ String toString() => "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+main() {
+ int d = 42;
+ f(a < b,
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c > --d);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t10.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t10.dart
new file mode 100644
index 0000000..6e4f003
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A26_t10.dart
@@ -0,0 +1,62 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '--' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+import "../../Utils/expect.dart";
+
+String f(a, [b]) => "$a, $b";
+
+class a<T1, T2> {
+ int x;
+ a(this.x);
+
+ @override
+ String toString() => "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Type {
+ bool operator< (Type t) => true;
+ int operator> (int i) => i;
+}
+
+main() {
+ int d = 42;
+ Expect.equals("true, 41", f(a < b, c > --d));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t01.dart
new file mode 100644
index 0000000..cf13379
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t01.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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '{' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+void f(x, [y]) {}
+
+main() {
+ int a = 1;
+ int b = 2;
+ int c = 3;
+ f(a<b,
+ c> {});
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t02.dart
new file mode 100644
index 0000000..abc55c6
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t02.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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '{' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String f(a, [b]) => "$a, $b";
+
+String a<T1, T2>(int x) {
+ return "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Function {
+ bool operator< (Type t) => true;
+}
+
+extension on Type {
+ int operator>(int i) => i;
+}
+
+main() {
+ f(a<b,
+ c> {});
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t03.dart
new file mode 100644
index 0000000..4413ddf
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A27_t03.dart
@@ -0,0 +1,64 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '{' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String f(a, [b]) => "$a, $b";
+
+class a<T1, T2> {
+ int x;
+ a(this.x);
+
+ @override
+ String toString() => "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Type {
+ bool operator< (Type t) => true;
+ int operator> (int i) => i;
+}
+
+main() {
+ f(a < b,
+ c > {});
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t01.dart
new file mode 100644
index 0000000..b8965e9
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t01.dart
@@ -0,0 +1,56 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '!' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+void f(x, [y]) {}
+
+main() {
+ int a = 1;
+ int b = 2;
+ int c = 3;
+ f(a<b,
+ c>!);
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+ f(a<b,
+ c> !true);
+// ^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t02.dart
new file mode 100644
index 0000000..f82c032
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t02.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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '!' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String f(a, [b]) => "$a, $b";
+
+String a<T1, T2>(int x) {
+ return "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Function {
+ bool operator< (Type t) => true;
+}
+
+extension on Type {
+ int operator>(bool i) => 42;
+}
+
+main() {
+ f(a<b,
+ c>!);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t03.dart
new file mode 100644
index 0000000..69824ae
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t03.dart
@@ -0,0 +1,61 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '!' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+String f(a, [b]) => "$a, $b";
+
+String a<T1, T2>(int x) {
+ return "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Function {
+ bool operator< (Type t) => true;
+}
+
+extension on Type {
+ bool operator>(bool b) => b;
+}
+
+main() {
+ Expect.equals("true, false", f(a < b, c > !true));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t04.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t04.dart
new file mode 100644
index 0000000..636bade
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t04.dart
@@ -0,0 +1,64 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '!' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+String f(a, [b]) => "$a, $b";
+
+class a<T1, T2> {
+ int x;
+ a(this.x);
+
+ @override
+ String toString() => "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Type {
+ bool operator< (Type t) => true;
+ int operator>(bool i) => 42;
+}
+
+main() {
+ f(a<b,
+ c>!);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t05.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t05.dart
new file mode 100644
index 0000000..c97eed6
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A28_t05.dart
@@ -0,0 +1,62 @@
+// 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 This new syntax also introduces new ambiguities in the grammar,
+/// similar to the one we introduced with generic functions. Examples include:
+///
+/// f(a<b,c>(d)); // Existing ambiguity, resolved to a generic method call.
+/// f(x.a<b,c>[d]); // f((x.a<b, c>)[d]) or f((x.a < b), (c > [d]))
+/// f(x.a<b,c>-d); // f((x.a<b, c>)-d) or f((x.a < b), (c > -d]))
+/// The x.a<b,c> can be an explicitly instantiated generic function tear-off or
+/// an explicitly instantiated type literal named using a prefix, which is new.
+/// While neither type objects nor functions declare operator- or operator[],
+/// such could be added using extension methods.
+///
+/// We will disambiguate such situations heuristically based on the token
+/// following the >. In the existing ambiguity we treat ( as a sign that it's a
+/// generic invocation. If the next character is one which cannot start a new
+/// expression (and thereby be the second operand of a > operator), the prior
+/// tokens is parsed as an explicit instantiation. If the token can start a new
+/// expression, then we make a choice depending on what we consider the most
+/// likely intention (that's specifically - and [ in the examples above).
+///
+/// The look-ahead tokens which force the prior tokens to be type arguments are:
+///
+/// ( ) ] } : ; , . ? == != .. ?. ?? ?..
+///
+/// & | ^ + * % / ~/
+///
+// Any other token following the ambiguous > will make the prior tokens be
+// parsed as comma separated < and > operator invocations.
+///
+/// @description Checks that any other token following the ambiguous > will make
+/// the prior tokens be parsed as comma separated < and > operator invocations.
+/// Test '!' token
+/// @author sgrekhov@unipro.ru
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import "../../Utils/expect.dart";
+
+String f(a, [b]) => "$a, $b";
+
+class a<T1, T2> {
+ int x;
+ a(this.x);
+
+ @override
+ String toString() => "a<$T1, $T2>($x)";
+}
+
+typedef b = int;
+typedef c = String;
+
+extension on Type {
+ bool operator>(bool b) => b;
+ bool operator< (Type t) => true;
+}
+
+main() {
+ Expect.equals("true, false", f(a < b, c > !true));
+}
