#1399. [Records] Interaction with legacy tests added (#1502)

Authored by @sgrekhov.

Author: sgrekhov

LanguageFeatures/Records/interaction_with_legacy_A01_t01.dart

@@ -0,0 +1,36 @@
+// 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 Assuming that v is the language version in which records are
+/// released, the following errors apply.
+///
+/// It is an error for the identifier [Record], denoting the [Record] class from
+/// dart:core, where that import scope name is only imported from platform
+/// libraries, to appear in a library whose language version is less than v.
+///
+/// @description Check that it is a compile-time error if class [Record] from
+/// dart:core is used in a library whose language version is less than v.
+/// @author [email protected]
+
+// @dart = 2.18
+
+// SharedOptions=--enable-experiment=records
+
+typedef T1 = Record;
+//           ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+T? foo<T>(T? t) => t;
+
+main() {
+  Record? r = null;
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  foo<Record>(null);
+//    ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Records/interaction_with_legacy_A02_t01.dart

@@ -0,0 +1,66 @@
+// 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 Assuming that v is the language version in which records are
+/// released, the following errors apply.
+///
+/// It is an error for the record literal syntax (e.g. (3, 4)) to be used
+/// syntactically in a library whose language version is less than v.
+///
+/// @description Check that it is a compile-time error if record literal syntax
+/// is used in a library whose language version is less than v.
+/// @author [email protected]
+
+// @dart = 2.18
+
+// SharedOptions=--enable-experiment=records
+
+void foo(dynamic x) {}
+
+main() {
+  var r1 = (1, 2);
+//         ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  var r2 = (1, n: 2);
+//         ^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  var r3 = (1,);
+//         ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  var r4 = ();
+//         ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  var r5 = (s: "x");
+//         ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  foo(());
+//    ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  foo((1,));
+//    ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  foo((1, 2));
+//    ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  foo((1, n: 42));
+//    ^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Records/interaction_with_legacy_A03_t01.dart

@@ -0,0 +1,69 @@
+// 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 Assuming that v is the language version in which records are
+/// released, the following errors apply.
+///
+/// It is an error for the record type syntax (e.g. (int, int)) to be used
+/// syntactically in a library whose language version is less than v.
+///
+/// @description Check that it is a compile-time error if record type syntax
+/// is used in a library whose language version is less than v.
+/// @author [email protected]
+
+// @dart = 2.18
+
+// SharedOptions=--enable-experiment=records
+
+typedef T1 = ();
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+typedef T2 = (int,);
+//           ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+typedef T3 = (int, String);
+//           ^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+typedef T4 = (int, {String s});
+//           ^^^^^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+typedef T5 = ({String s});
+//           ^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+main() {
+  ()? r1 = null;
+//^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  (int,)? r2 = null;
+//^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  (int, String)? r3 = null;
+//^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  (int, {String s})? r4 = null;
+//^^^^^^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  ({String s})? r5 = null;
+//^^^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Records/interaction_with_legacy_A04_t01.dart

@@ -0,0 +1,47 @@
+// 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 It is not an error for a library whose language version is less
+/// than v (a "legacy library") to include types which denote or include the
+/// [Record] class, record types or record expressions when these terms arise
+/// directly or indirectly from references to another library whose language
+/// version is greater than or equal to v. For example, such a legacy library
+/// may reference a typedef name which is bound to a record type in another
+/// library, and the semantic interpretation of the typedef is as the underlying
+/// record type, just as it would be for any other type. Similarly, type
+/// inference may introduce record types into a legacy library, and such types
+/// will be interpreted by the compiler as record types as usual (that is, there
+/// is no erasure implied to remove these inferred types). A legacy library may
+/// refer to the [Record] class via a library which has re-exported it. Record
+/// values may flow into a legacy library via a reference to a member from
+/// another library, and a legacy library may freely call getters on record
+/// values (since there is no new syntax for calling a record getter). The
+/// rationale for the choices described in this section is that the intent of
+/// language versioning (for an additive feature such as records) is to ensure
+/// that users do not accidentally use new features in a package without
+/// specifying an SDK constraint which ensures that their code will always be
+/// run on an SDK which supports the feature. But in the case of a legacy
+/// library which references record values or types indirectly via another
+/// library, the SDK constraint on the referenced library is sufficient to
+/// enforce this.
+///
+/// @description Check that it is not an error if legacy library includes types
+/// which denote or include record types or record expressions from not legacy
+/// library
+/// @author [email protected]
+
+// @dart = 2.18
+
+// SharedOptions=--enable-experiment=records
+
+import "interaction_with_legacy_lib.dart";
+
+main() {
+  R0 _r0 = r0;
+  R1 _r1 = r1;
+  R2 _r2 = r2;
+  R3 _r3 = r3;
+  R4 _r4 = r4;
+  Rec _rec = rec;
+}

LanguageFeatures/Records/interaction_with_legacy_A04_t02.dart

@@ -0,0 +1,60 @@
+// 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 It is not an error for a library whose language version is less
+/// than v (a "legacy library") to include types which denote or include the
+/// [Record] class, record types or record expressions when these terms arise
+/// directly or indirectly from references to another library whose language
+/// version is greater than or equal to v. For example, such a legacy library
+/// may reference a typedef name which is bound to a record type in another
+/// library, and the semantic interpretation of the typedef is as the underlying
+/// record type, just as it would be for any other type. Similarly, type
+/// inference may introduce record types into a legacy library, and such types
+/// will be interpreted by the compiler as record types as usual (that is, there
+/// is no erasure implied to remove these inferred types). A legacy library may
+/// refer to the [Record] class via a library which has re-exported it. Record
+/// values may flow into a legacy library via a reference to a member from
+/// another library, and a legacy library may freely call getters on record
+/// values (since there is no new syntax for calling a record getter). The
+/// rationale for the choices described in this section is that the intent of
+/// language versioning (for an additive feature such as records) is to ensure
+/// that users do not accidentally use new features in a package without
+/// specifying an SDK constraint which ensures that their code will always be
+/// run on an SDK which supports the feature. But in the case of a legacy
+/// library which references record values or types indirectly via another
+/// library, the SDK constraint on the referenced library is sufficient to
+/// enforce this.
+///
+/// @description Check that type inference may introduce record types into a
+/// legacy library, and such types will be interpreted by the compiler as record
+/// types as usual
+/// @author [email protected]
+
+// @dart = 2.18
+
+// SharedOptions=--enable-experiment=records
+
+import "interaction_with_legacy_lib.dart";
+
+main() {
+  Object _r1 = r1;
+  Object _r2 = r2;
+  Object _r3 = r3;
+  Object _r4 = r4;
+
+  if (_r1 is R1) {
+    _r1.$0;
+  }
+  if (_r2 is R2) {
+    _r2.$0;
+    _r2.$1;
+  }
+  if (_r3 is R3) {
+    _r3.$0;
+    _r3.name;
+  }
+  if (_r4 is R4) {
+    _r4.s;
+  }
+}

LanguageFeatures/Records/interaction_with_legacy_A04_t03.dart

@@ -0,0 +1,55 @@
+// 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 It is not an error for a library whose language version is less
+/// than v (a "legacy library") to include types which denote or include the
+/// [Record] class, record types or record expressions when these terms arise
+/// directly or indirectly from references to another library whose language
+/// version is greater than or equal to v. For example, such a legacy library
+/// may reference a typedef name which is bound to a record type in another
+/// library, and the semantic interpretation of the typedef is as the underlying
+/// record type, just as it would be for any other type. Similarly, type
+/// inference may introduce record types into a legacy library, and such types
+/// will be interpreted by the compiler as record types as usual (that is, there
+/// is no erasure implied to remove these inferred types). A legacy library may
+/// refer to the [Record] class via a library which has re-exported it. Record
+/// values may flow into a legacy library via a reference to a member from
+/// another library, and a legacy library may freely call getters on record
+/// values (since there is no new syntax for calling a record getter). The
+/// rationale for the choices described in this section is that the intent of
+/// language versioning (for an additive feature such as records) is to ensure
+/// that users do not accidentally use new features in a package without
+/// specifying an SDK constraint which ensures that their code will always be
+/// run on an SDK which supports the feature. But in the case of a legacy
+/// library which references record values or types indirectly via another
+/// library, the SDK constraint on the referenced library is sufficient to
+/// enforce this.
+///
+/// @description Check that a legacy library may refer to the [Record] class via
+/// a library which has re-exported it
+/// @author [email protected]
+
+// @dart = 2.18
+
+// SharedOptions=--enable-experiment=records
+
+import "interaction_with_legacy_lib.dart";
+
+Record foo<T extends Record>(T t) => t;
+
+main() {
+  Record _r0 = r0;
+  Record _r1 = r1;
+  Record _r2 = r2;
+  Record _r3 = r3;
+  Record _r4 = r4;
+  Record _rec = rec;
+
+  foo(_rec);
+  foo<R0>(_r0);
+  foo<R1>(_r1);
+  foo<R2>(_r2);
+  foo<R3>(_r3);
+  foo<R4>(_r4);
+}

LanguageFeatures/Records/interaction_with_legacy_A04_t04.dart

@@ -0,0 +1,54 @@
+// 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 It is not an error for a library whose language version is less
+/// than v (a "legacy library") to include types which denote or include the
+/// [Record] class, record types or record expressions when these terms arise
+/// directly or indirectly from references to another library whose language
+/// version is greater than or equal to v. For example, such a legacy library
+/// may reference a typedef name which is bound to a record type in another
+/// library, and the semantic interpretation of the typedef is as the underlying
+/// record type, just as it would be for any other type. Similarly, type
+/// inference may introduce record types into a legacy library, and such types
+/// will be interpreted by the compiler as record types as usual (that is, there
+/// is no erasure implied to remove these inferred types). A legacy library may
+/// refer to the [Record] class via a library which has re-exported it. Record
+/// values may flow into a legacy library via a reference to a member from
+/// another library, and a legacy library may freely call getters on record
+/// values (since there is no new syntax for calling a record getter). The
+/// rationale for the choices described in this section is that the intent of
+/// language versioning (for an additive feature such as records) is to ensure
+/// that users do not accidentally use new features in a package without
+/// specifying an SDK constraint which ensures that their code will always be
+/// run on an SDK which supports the feature. But in the case of a legacy
+/// library which references record values or types indirectly via another
+/// library, the SDK constraint on the referenced library is sufficient to
+/// enforce this.
+///
+/// @description Check that a record values may flow into a legacy library via a
+/// reference to a member from another library, and a legacy library may freely
+/// call getters on record values
+/// @author [email protected]
+
+// @dart = 2.18
+
+// SharedOptions=--enable-experiment=records
+
+import "interaction_with_legacy_lib.dart";
+import "../../Utils/expect.dart";
+
+main() {
+  Expect.equals(42, r1.$0);
+  Expect.equals(1, r2.$0);
+  Expect.equals("one", r2.$1);
+  Expect.equals(3.14, r3.$0);
+  Expect.equals("pi", r3.name);
+  Expect.equals("Lily was here", r4.s);
+  Expect.equals(1, rec.$0);
+  Expect.equals(2, rec.$1);
+  Expect.equals(3, rec.$2);
+  Expect.equals("1", rec.one);
+  Expect.equals("2", rec.two);
+  Expect.equals("3", rec.three);
+}