#1399. [Records] Tests for ambiguity with metadata annotations added (#1524)

Authored by @sgrekhov.

Add tests for ambiguity with metadata annotations.

Author: sgrekhov

LanguageFeatures/Records/metadata_annotations_A01_t01.dart

@@ -0,0 +1,64 @@
+// 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 @metadata (a, b) function() {}
+/// This could be a metadata annotation @metadata(a, b) associated with a
+/// function declaration with no return type. Or it could be a metadata
+/// annotation @metadata associated with a function whose return type is the
+/// record type (a, b).
+///
+/// In practice, idiomatically written code is clear thanks to whitespace:
+///
+/// @metadata(a, b) function() {}
+///
+/// @metadata (a, b) function() {}
+///
+/// The former applies (a, b) to the metadata annotation and the latter is a
+/// return type. We disambiguate in the same way, by making whitespace after a
+/// metadata annotation name significant. Change the grammar to:
+///
+/// metadatum ::= identifier                                 // Existing rule.
+///             | qualifiedName                              // Existing rule.
+///             | constructorDesignation NO_SPACE arguments  // Changed.
+/// The NO_SPACE lexical rule matches when there are no whitespace characters or
+/// comments (according to the existing WHITESPACE and COMMENT lexical rules)
+/// between the constructorDesignation and arguments. In other words, for an
+/// argument list to be part of the metadata annotation, the ( must occur
+/// immediately after the last character in the constructorDesignation. The last
+/// character in constructorDesignation may be an identifier or the > in a type
+/// argument list.
+///
+/// @description Checks that if there is a space between @metadata and (a, b)
+/// then (a, b) denotes a record. Test functions with no comment between a
+/// metadata and a return type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+
+const Meta = "meta";
+
+@Meta (int, String) foo1() => (1, "2");
+
+@Meta
+(int, String) foo2() => (3, "4");
+
+@Meta () foo3() => ();
+
+@Meta
+() foo4() => ();
+
+@Meta (int, {String name}) foo5() => (5, name: "name");
+
+main() {
+  Expect.equals(1, foo1().$0);
+  Expect.equals("2", foo1().$1);
+  Expect.equals(3, foo2().$0);
+  Expect.equals("4", foo2().$1);
+  Expect.equals((), foo3());
+  Expect.equals((), foo4());
+  Expect.equals(5, foo5().$0);
+  Expect.equals("name", foo5().name);
+}

LanguageFeatures/Records/metadata_annotations_A01_t02.dart

@@ -0,0 +1,68 @@
+// 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 @metadata (a, b) function() {}
+/// This could be a metadata annotation @metadata(a, b) associated with a
+/// function declaration with no return type. Or it could be a metadata
+/// annotation @metadata associated with a function whose return type is the
+/// record type (a, b).
+///
+/// In practice, idiomatically written code is clear thanks to whitespace:
+///
+/// @metadata(a, b) function() {}
+///
+/// @metadata (a, b) function() {}
+///
+/// The former applies (a, b) to the metadata annotation and the latter is a
+/// return type. We disambiguate in the same way, by making whitespace after a
+/// metadata annotation name significant. Change the grammar to:
+///
+/// metadatum ::= identifier                                 // Existing rule.
+///             | qualifiedName                              // Existing rule.
+///             | constructorDesignation NO_SPACE arguments  // Changed.
+/// The NO_SPACE lexical rule matches when there are no whitespace characters or
+/// comments (according to the existing WHITESPACE and COMMENT lexical rules)
+/// between the constructorDesignation and arguments. In other words, for an
+/// argument list to be part of the metadata annotation, the ( must occur
+/// immediately after the last character in the constructorDesignation. The last
+/// character in constructorDesignation may be an identifier or the > in a type
+/// argument list.
+///
+/// @description Checks that if there is a space between @metadata and (a, b)
+/// then (a, b) denotes a record. Test functions with comment between a
+/// metadata and a return type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+
+const Meta = "meta";
+
+@Meta/* comment */(int, String) foo1() => (1, "2");
+
+@Meta// comment
+(int, String) foo2() => (3, "4");
+
+@Meta /* comment */() foo3() => ();
+
+@Meta// comment
+() foo4() => ();
+
+@Meta/* comment */ (int, {String name}) foo5() => (5, name: "name");
+
+@Meta /* comment */ (int, {String name}) foo6() => (6, name: "name");
+
+main() {
+  Expect.equals(1, foo1().$0);
+  Expect.equals("2", foo1().$1);
+  Expect.equals(3, foo2().$0);
+  Expect.equals("4", foo2().$1);
+  Expect.equals((), foo3());
+  Expect.equals((), foo4());
+  Expect.equals(5, foo5().$0);
+  Expect.equals("name", foo5().name);
+  Expect.equals(6, foo6().$0);
+  Expect.equals("name", foo6().name);
+}

LanguageFeatures/Records/metadata_annotations_A01_t03.dart

@@ -0,0 +1,64 @@
+// 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 @metadata (a, b) function() {}
+/// This could be a metadata annotation @metadata(a, b) associated with a
+/// function declaration with no return type. Or it could be a metadata
+/// annotation @metadata associated with a function whose return type is the
+/// record type (a, b).
+///
+/// In practice, idiomatically written code is clear thanks to whitespace:
+///
+/// @metadata(a, b) function() {}
+///
+/// @metadata (a, b) function() {}
+///
+/// The former applies (a, b) to the metadata annotation and the latter is a
+/// return type. We disambiguate in the same way, by making whitespace after a
+/// metadata annotation name significant. Change the grammar to:
+///
+/// metadatum ::= identifier                                 // Existing rule.
+///             | qualifiedName                              // Existing rule.
+///             | constructorDesignation NO_SPACE arguments  // Changed.
+/// The NO_SPACE lexical rule matches when there are no whitespace characters or
+/// comments (according to the existing WHITESPACE and COMMENT lexical rules)
+/// between the constructorDesignation and arguments. In other words, for an
+/// argument list to be part of the metadata annotation, the ( must occur
+/// immediately after the last character in the constructorDesignation. The last
+/// character in constructorDesignation may be an identifier or the > in a type
+/// argument list.
+///
+/// @description Checks that if there is a space between @metadata and (a, b)
+/// then (a, b) denotes a record. Test variables declaration with no comment
+/// between a metadata and a return type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+
+const Meta = "meta";
+
+main() {
+  @Meta (int, String) r1 = (1, "2");
+
+  @Meta
+  (int, String) r2 = (3, "4");
+
+  @Meta () r3 = ();
+
+  @Meta
+  () r4 = ();
+
+  @Meta (int, {String name}) r5 = (5, name: "name");
+
+  Expect.equals(1, r1.$0);
+  Expect.equals("2", r1.$1);
+  Expect.equals(3, r2.$0);
+  Expect.equals("4", r2.$1);
+  Expect.equals((), r3);
+  Expect.equals((), r4);
+  Expect.equals(5, r5.$0);
+  Expect.equals("name", r5.name);
+}

LanguageFeatures/Records/metadata_annotations_A01_t04.dart

@@ -0,0 +1,68 @@
+// 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 @metadata (a, b) function() {}
+/// This could be a metadata annotation @metadata(a, b) associated with a
+/// function declaration with no return type. Or it could be a metadata
+/// annotation @metadata associated with a function whose return type is the
+/// record type (a, b).
+///
+/// In practice, idiomatically written code is clear thanks to whitespace:
+///
+/// @metadata(a, b) function() {}
+///
+/// @metadata (a, b) function() {}
+///
+/// The former applies (a, b) to the metadata annotation and the latter is a
+/// return type. We disambiguate in the same way, by making whitespace after a
+/// metadata annotation name significant. Change the grammar to:
+///
+/// metadatum ::= identifier                                 // Existing rule.
+///             | qualifiedName                              // Existing rule.
+///             | constructorDesignation NO_SPACE arguments  // Changed.
+/// The NO_SPACE lexical rule matches when there are no whitespace characters or
+/// comments (according to the existing WHITESPACE and COMMENT lexical rules)
+/// between the constructorDesignation and arguments. In other words, for an
+/// argument list to be part of the metadata annotation, the ( must occur
+/// immediately after the last character in the constructorDesignation. The last
+/// character in constructorDesignation may be an identifier or the > in a type
+/// argument list.
+///
+/// @description Checks that if there is a space between @metadata and (a, b)
+/// then (a, b) denotes a record. Test variables declaration with a comment
+/// between a metadata and a return type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+import "../../Utils/expect.dart";
+
+const Meta = "meta";
+
+main() {
+  @Meta/* comment */(int, String) r1 = (1, "2");
+
+  @Meta// comment
+  (int, String) r2 = (3, "4");
+
+  @Meta/* comment */ () r3 = ();
+
+  @Meta // comment
+  () r4 = ();
+
+  @Meta /* comment */(int, {String name}) r5 = (5, name: "name");
+
+  @Meta /* comment */ (int, {String name}) r6 = (6, name: "name");
+
+  Expect.equals(1, r1.$0);
+  Expect.equals("2", r1.$1);
+  Expect.equals(3, r2.$0);
+  Expect.equals("4", r2.$1);
+  Expect.equals((), r3);
+  Expect.equals((), r4);
+  Expect.equals(5, r5.$0);
+  Expect.equals("name", r5.name);
+  Expect.equals(6, r5.$0);
+  Expect.equals("name", r6.name);
+}

LanguageFeatures/Records/metadata_annotations_A01_t05.dart

@@ -0,0 +1,98 @@
+// 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 @metadata (a, b) function() {}
+/// This could be a metadata annotation @metadata(a, b) associated with a
+/// function declaration with no return type. Or it could be a metadata
+/// annotation @metadata associated with a function whose return type is the
+/// record type (a, b).
+///
+/// In practice, idiomatically written code is clear thanks to whitespace:
+///
+/// @metadata(a, b) function() {}
+///
+/// @metadata (a, b) function() {}
+///
+/// The former applies (a, b) to the metadata annotation and the latter is a
+/// return type. We disambiguate in the same way, by making whitespace after a
+/// metadata annotation name significant. Change the grammar to:
+///
+/// metadatum ::= identifier                                 // Existing rule.
+///             | qualifiedName                              // Existing rule.
+///             | constructorDesignation NO_SPACE arguments  // Changed.
+/// The NO_SPACE lexical rule matches when there are no whitespace characters or
+/// comments (according to the existing WHITESPACE and COMMENT lexical rules)
+/// between the constructorDesignation and arguments. In other words, for an
+/// argument list to be part of the metadata annotation, the ( must occur
+/// immediately after the last character in the constructorDesignation. The last
+/// character in constructorDesignation may be an identifier or the > in a type
+/// argument list.
+///
+/// @description Checks that it is a compile-time error if there is a space
+/// between metadata and its arguments list.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=records
+
+class Meta {
+  const Meta(Type t1, Type t2);
+}
+
+class M {
+  const M();
+}
+
+/**/@Meta (int, String) foo1() => (1, "2");
+//  ^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+/**/@Meta
+//  ^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  (int, String) foo2() => (3, "4");
+
+/**/@M () foo3() => ();
+//  ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+/**/@M
+//  ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+() foo4() => ();
+
+/**/@Meta/* comment */(int, String) foo5() => (5, "6");
+//  ^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+/**/@Meta // comment
+//  ^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  (int, String) foo6() => (7, "8");
+
+/**/@M/* comment */ () foo7() => ();
+//  ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+/**/@M // comment
+//  ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  () foo8() => ();
+
+main() {
+  foo1();
+  foo2();
+  foo3();
+  foo4();
+  foo5();
+  foo6();
+  foo7();
+  foo8();
+}