#1087. Resolving ambiguities tests added
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A01_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A01_t03.dart
index dd76bc2..d896013 100644
--- a/LanguageFeatures/Constructor-tear-offs/ambiguities_A01_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A01_t03.dart
@@ -43,6 +43,7 @@
int x;
a(this.x);
+ @override
String toString() => "a<$T1, $T2>($x)";
}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A02_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A02_t03.dart
index 93978cb..84a7f8c 100644
--- a/LanguageFeatures/Constructor-tear-offs/ambiguities_A02_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A02_t03.dart
@@ -43,6 +43,7 @@
int x;
a(this.x);
+ @override
String toString() => "a<$T1, $T2>($x)";
}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A03_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A03_t03.dart
index f7e917b..51cf6a9 100644
--- a/LanguageFeatures/Constructor-tear-offs/ambiguities_A03_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A03_t03.dart
@@ -43,6 +43,7 @@
int x;
a(this.x);
+ @override
String toString() => "a<$T1, $T2>($x)";
}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A04_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A04_t03.dart
index 90870e7..653cb2c 100644
--- a/LanguageFeatures/Constructor-tear-offs/ambiguities_A04_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A04_t03.dart
@@ -43,6 +43,7 @@
int x;
a(this.x);
+ @override
String toString() => "a<$T1, $T2>($x)";
}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A05_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A05_t03.dart
index e15f4aa..ce926d4 100644
--- a/LanguageFeatures/Constructor-tear-offs/ambiguities_A05_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A05_t03.dart
@@ -43,6 +43,7 @@
int x;
a(this.x);
+ @override
String toString() => "a<$T1, $T2>($x)";
}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A06_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A06_t03.dart
index 4387acc..f10b245 100644
--- a/LanguageFeatures/Constructor-tear-offs/ambiguities_A06_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A06_t03.dart
@@ -43,6 +43,7 @@
int x;
a(this.x);
+ @override
String toString() => "a<$T1, $T2>($x)";
}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t01.dart
new file mode 100644
index 0000000..bdfb126
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t01.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(bool x, [y, z]) {}
+
+main() {
+ int a = 1;
+ int b = 2;
+ int c = 3;
+ int d = 4;
+ f(a<b,
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c>, d);
+// ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t02.dart
new file mode 100644
index 0000000..d04b4c5
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t02.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 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
+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;
+
+main() {
+ int d = 42;
+ Expect.equals("${a<b, c>}, 42", f(a<b, c>, d));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t03.dart
new file mode 100644
index 0000000..0946672
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A07_t03.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 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
+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;
+
+main() {
+ int d = 42;
+ Expect.equals("${a<b, c>}, 42",f(a<b, c>, d));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t01.dart
new file mode 100644
index 0000000..f2d9fd6
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t01.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 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>.toString());
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t02.dart
new file mode 100644
index 0000000..c5a6896
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t02.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 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
+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;
+
+main() {
+ Expect.equals("${a<b, c>}, null", f(a<b, c>.toString()));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t03.dart
new file mode 100644
index 0000000..dc03265
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A08_t03.dart
@@ -0,0 +1,55 @@
+// 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
+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;
+
+main() {
+ Expect.equals("${a<b, c>}, null",f(a<b, c>.toString()));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A09_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A09_t01.dart
new file mode 100644
index 0000000..751eedb
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A09_t01.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 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;
+ bool c = true;
+ f(a<b,
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+ c>? 4 : 2);
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t01.dart
new file mode 100644
index 0000000..34c77fe
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t01.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 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>== 4);
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t02.dart
new file mode 100644
index 0000000..1fe508f
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t02.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 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
+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;
+
+main() {
+ var x = a<b, c>;
+ Expect.equals("true, null", f(a<b, c> == x));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t03.dart
new file mode 100644
index 0000000..16b9e1c
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A10_t03.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 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
+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;
+
+main() {
+ var x = a<b, c>;
+ Expect.equals("true, null", f(a<b, c> == x));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t01.dart
new file mode 100644
index 0000000..d3b9260
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t01.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 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>!= 4);
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t02.dart
new file mode 100644
index 0000000..bee21f5
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t02.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 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
+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;
+
+main() {
+ var x = a<b, c>;
+ Expect.equals("false, null", f(a<b, c> != x));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t03.dart
new file mode 100644
index 0000000..8159fcf
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A11_t03.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 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
+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;
+
+main() {
+ var x = a<b, c>;
+ Expect.equals("false, null", f(a<b, c> != x));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t01.dart
new file mode 100644
index 0000000..194118f
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t01.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 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>..toString());
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t02.dart
new file mode 100644
index 0000000..2c933be
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t02.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 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
+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;
+
+main() {
+ Expect.equals("${a<b, c>}, null", f(a<b, c>..toString()));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t03.dart
new file mode 100644
index 0000000..103b451
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A12_t03.dart
@@ -0,0 +1,55 @@
+// 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
+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;
+
+main() {
+ Expect.equals("${a<b, c>}, null",f(a<b, c>..toString()));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t01.dart
new file mode 100644
index 0000000..79ce550
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t01.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 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>?.toString());
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t02.dart
new file mode 100644
index 0000000..ba8e3fd
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t02.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>)?. . Test generic function tear-off
+/// @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;
+
+main() {
+ Expect.equals("${a<b, c>}, null", f(a<b, c>?.toString()));
+// ^^
+// [analyzer] STATIC_WARNING.INVALID_NULL_AWARE_OPERATOR
+// [cfe] Operand of null-aware operation '?.' has type 'String Function<int, String>(int)' which excludes null.
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t03.dart
new file mode 100644
index 0000000..e2b35ee
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A13_t03.dart
@@ -0,0 +1,58 @@
+// 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
+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;
+
+main() {
+ Expect.equals("${a<b, c>}, null", f(a<b, c>?.toString()));
+// ^^
+// [analyzer] STATIC_WARNING.INVALID_NULL_AWARE_OPERATOR
+// [cfe] Operand of null-aware operation '?.' has type 'Type' which excludes null.
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t01.dart
new file mode 100644
index 0000000..d523ab7
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t01.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 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> ?? 4);
+// ^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t02.dart
new file mode 100644
index 0000000..d5e1a32
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t02.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>)?? . Test generic function tear-off
+/// @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;
+
+main() {
+ Expect.equals("${a<b, c>}, null", f(a<b, c> ?? "Lily was here"));
+// ^^
+// [analyzer] STATIC_WARNING.INVALID_NULL_AWARE_OPERATOR
+// [cfe] Operand of null-aware operation '?.' has type 'String Function<int, String>(int)' which excludes null.
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t03.dart
new file mode 100644
index 0000000..33371ae
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A14_t03.dart
@@ -0,0 +1,55 @@
+// 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
+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;
+
+main() {
+ Expect.equals("${a<b, c>}, null", f(a<b, c> ?? "Lily was here"));
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t01.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t01.dart
new file mode 100644
index 0000000..e1ed783
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t01.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 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>?..toString());
+// ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t02.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t02.dart
new file mode 100644
index 0000000..aac9ba5
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t02.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>)?.. . Test generic function tear-off
+/// @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;
+
+main() {
+ Expect.equals("${a<b, c>}, null", f(a<b, c>?..toString()));
+// ^^^
+// [analyzer] STATIC_WARNING.INVALID_NULL_AWARE_OPERATOR
+// [cfe] Operand of null-aware operation '?..' has type 'String Function<int, String>(int)' which excludes null.
+}
diff --git a/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t03.dart b/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t03.dart
new file mode 100644
index 0000000..04e6a26
--- /dev/null
+++ b/LanguageFeatures/Constructor-tear-offs/ambiguities_A15_t03.dart
@@ -0,0 +1,58 @@
+// 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
+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;
+
+main() {
+ Expect.equals("${a<b, c>}, null", f(a<b, c>?..toString()));
+// ^^^
+// [analyzer] STATIC_WARNING.INVALID_NULL_AWARE_OPERATOR
+// [cfe] Operand of null-aware operation '?..' has type 'Type' which excludes null.
+}
