#1399. on clause tests added (#1416)

Authored by @sgrekhov.

Author: sgrekhov

LanguageFeatures/Records/on_clauses_A01_t01.dart

@@ -0,0 +1,40 @@
+// Copyright (c) 2022, 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 Consider:
+///
+/// void foo() {
+///   try {
+///     ;
+///   } on Bar {
+///     ;
+///   }
+///   on(a, b) {;} // <--
+/// }
+/// Before, the marked line could only be declaring a local function named `on`.
+/// With record types, it could be a second `on` clause for the `try` statement
+/// whose matched type is the record type `(a, b)`. When presented with this
+/// ambiguity, we disambiguate by treating `on` as a clause for `try` and not a
+/// local function. This is technically a breaking change, but is unlikely to
+/// affect any code in the wild.
+///
+/// @description Checks that in the case above `on` is treated as a clause for
+/// `try`, not as a local function
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+
+main() {
+  bool caught = false;
+  try {
+    throw (42, "Lily was here");
+  } on String {
+    Expect.fail("Unexpected String exception");
+  } on (int i, String n) {
+    caught = true;
+  }
+  Expect.isTrue(caught);
+}

LanguageFeatures/Records/on_clauses_A01_t02.dart

@@ -0,0 +1,48 @@
+// Copyright (c) 2022, 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 Consider:
+///
+/// void foo() {
+///   try {
+///     ;
+///   } on Bar {
+///     ;
+///   }
+///   on(a, b) {;} // <--
+/// }
+/// Before, the marked line could only be declaring a local function named `on`.
+/// With record types, it could be a second `on` clause for the `try` statement
+/// whose matched type is the record type `(a, b)`. When presented with this
+/// ambiguity, we disambiguate by treating `on` as a clause for `try` and not a
+/// local function. This is technically a breaking change, but is unlikely to
+/// affect any code in the wild.
+///
+/// @description Checks that in the case above `on` is treated as a clause for
+/// `try` and correct clause is executed
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+
+main() {
+  bool caught = false;
+  try {
+    throw (42, n: "Lily was here");
+  } on String {
+    Expect.fail("Unexpected String exception");
+  } on int {
+    Expect.fail("Unexpected int exception");
+  } on (int, int) {
+    Expect.fail("Unexpected (int, int) exception");
+  } on (int i, {String? x}) {
+    Expect.fail("Unexpected (int, {String? x}) exception");
+  } on (int i, {String? n}) {
+    caught = true;
+  } on (num, String) {
+    Expect.fail("Unexpected (int, {String? x}) exception");
+  }
+  Expect.isTrue(caught);
+}

LanguageFeatures/Records/on_clauses_A01_t03.dart

@@ -0,0 +1,38 @@
+// Copyright (c) 2022, 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 Consider:
+///
+/// void foo() {
+///   try {
+///     ;
+///   } on Bar {
+///     ;
+///   }
+///   on(a, b) {;} // <--
+/// }
+/// Before, the marked line could only be declaring a local function named `on`.
+/// With record types, it could be a second `on` clause for the `try` statement
+/// whose matched type is the record type `(a, b)`. When presented with this
+/// ambiguity, we disambiguate by treating `on` as a clause for `try` and not a
+/// local function. This is technically a breaking change, but is unlikely to
+/// affect any code in the wild.
+///
+/// @description Checks that in the case above `on` is treated as a clause for
+/// `try`, not as a local function
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+main() {
+  try {
+    print(0);
+  } on String {
+  } on (int i, {String? n}) {
+  }
+  on(42, n: "Lily was here");
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Records/on_clauses_A02_t01.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2022, 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 Consider:
+///
+/// void foo() {
+///   try {
+///     ;
+///   } on Bar {
+///     ;
+///   }
+///   on(a, b) {;} // <--
+/// }
+/// Before, the marked line could only be declaring a local function named `on`.
+/// With record types, it could be a second `on` clause for the `try` statement
+/// whose matched type is the record type `(a, b)`. When presented with this
+/// ambiguity, we disambiguate by treating `on` as a clause for `try` and not a
+/// local function. This is technically a breaking change, but is unlikely to
+/// affect any code in the wild.
+///
+/// @description Checks that in the case above `on` is treated as a clause for
+/// `try`, not as a local function. Test the case when `on` clause looks like a
+/// function with optional positional parameters
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+main() {
+  try {
+    print(0);
+  } on String {
+  } on ([int? i, String? n]) {
+//      ^
+// [analyzer] unspecified
+// [cfe] unspecified
+  }
+  on();
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Records/on_clauses_A02_t02.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2022, 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 Consider:
+///
+/// void foo() {
+///   try {
+///     ;
+///   } on Bar {
+///     ;
+///   }
+///   on(a, b) {;} // <--
+/// }
+/// Before, the marked line could only be declaring a local function named `on`.
+/// With record types, it could be a second `on` clause for the `try` statement
+/// whose matched type is the record type `(a, b)`. When presented with this
+/// ambiguity, we disambiguate by treating `on` as a clause for `try` and not a
+/// local function. This is technically a breaking change, but is unlikely to
+/// affect any code in the wild.
+///
+/// @description Checks that in the case above `on` is treated as a clause for
+/// `try`, not as a local function. Test the case when `on` clause looks like a
+/// function with optional positional parameters and default values specified
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+main() {
+  try {
+    print(0);
+  } on String {
+  } on ([int i = 0, String n = ""]) {
+//      ^
+// [analyzer] unspecified
+// [cfe] unspecified
+  }
+  on();
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Records/on_clauses_A02_t03.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2022, 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 Consider:
+///
+/// void foo() {
+///   try {
+///     ;
+///   } on Bar {
+///     ;
+///   }
+///   on(a, b) {;} // <--
+/// }
+/// Before, the marked line could only be declaring a local function named `on`.
+/// With record types, it could be a second `on` clause for the `try` statement
+/// whose matched type is the record type `(a, b)`. When presented with this
+/// ambiguity, we disambiguate by treating `on` as a clause for `try` and not a
+/// local function. This is technically a breaking change, but is unlikely to
+/// affect any code in the wild.
+///
+/// @description Checks that in the case above `on` is treated as a clause for
+/// `try`, not as a local function. Test the case when `on` clause looks like a
+/// function with required named parameters
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+main() {
+  try {
+    print(0);
+  } on String {
+  } on (int i, {required String n}) {
+//              ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  }
+  on(42, n: "");
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Records/on_clauses_A02_t04.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2022, 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 Consider:
+///
+/// void foo() {
+///   try {
+///     ;
+///   } on Bar {
+///     ;
+///   }
+///   on(a, b) {;} // <--
+/// }
+/// Before, the marked line could only be declaring a local function named `on`.
+/// With record types, it could be a second `on` clause for the `try` statement
+/// whose matched type is the record type `(a, b)`. When presented with this
+/// ambiguity, we disambiguate by treating `on` as a clause for `try` and not a
+/// local function. This is technically a breaking change, but is unlikely to
+/// affect any code in the wild.
+///
+/// @description Checks that in the case above `on` is treated as a clause for
+/// `try`, not as a local function. Test the case when `on` clause looks like a
+/// function with default values for optional parameters specified
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+main() {
+  try {
+    print(0);
+  } on String {
+  } on (int i, {String n = ""}) {
+//              ^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  }
+  on(42);
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Records/on_clauses_A02_t05.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2022, 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 Consider:
+///
+/// void foo() {
+///   try {
+///     ;
+///   } on Bar {
+///     ;
+///   }
+///   on(a, b) {;} // <--
+/// }
+/// Before, the marked line could only be declaring a local function named `on`.
+/// With record types, it could be a second `on` clause for the `try` statement
+/// whose matched type is the record type `(a, b)`. When presented with this
+/// ambiguity, we disambiguate by treating `on` as a clause for `try` and not a
+/// local function. This is technically a breaking change, but is unlikely to
+/// affect any code in the wild.
+///
+/// @description Checks that in the case above `on` is treated as a clause for
+/// `try`, not as a local function. Test the case when `on` clause looks like a
+/// function with type parameter
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+main() {
+  try {
+    print(0);
+  } on String {
+  } on<T>(int i, {String? n}) {
+//  ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  }
+  on(42, n: "");
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}