#1400. Composing inline classes tests (#2076)

Composing inline classes tests

Author: sgrekhov

LanguageFeatures/Inline-classes/composing_inline_classes_A01_t01.dart

@@ -0,0 +1,41 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+///
+/// A compile-time error occurs if V1 is a type name or a parameterized type
+/// which occurs as a superinterface in an inline class declaration DV, but V1
+/// does not denote an inline type.
+///
+/// @description Checks that it is a compile-time error if superinterface of an
+/// inline class is not an inline type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+class I1 {}
+class I2<T1, T2> {}
+
+inline class V1 implements I1 {
+//                         ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final int it;
+  V1(this.it);
+}
+
+inline class V2<T1, T2 extends num?> implements I2<T1, T2> {
+//                                              ^^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final T1 id;
+  V2(this.id);
+}
+
+main() {
+  print(V1);
+  print(V2);
+}

LanguageFeatures/Inline-classes/composing_inline_classes_A02_t01.dart

@@ -0,0 +1,48 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+/// ...
+/// A compile-time error occurs if any direct or indirect superinterface of DV
+/// is the type Inline or a type of the form Inline<...>
+///
+/// @description Checks that it is a compile-time error if an inline class has a
+/// dependency on itself.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V1 implements V2 {
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final int id;
+  V1(this.id);
+}
+
+inline class V2 implements V3 {
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final int id;
+  V2(this.id);
+}
+
+typedef V1Alias = V1;
+
+inline class V3 implements V1Alias {
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final int id;
+  V3(this.id);
+}
+
+main() {
+  print(V1);
+  print(V2);
+  print(V3);
+}

LanguageFeatures/Inline-classes/composing_inline_classes_A02_t02.dart

@@ -0,0 +1,48 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+/// ...
+/// A compile-time error occurs if any direct or indirect superinterface of DV
+/// is the type Inline or a type of the form Inline<...>
+///
+/// @description Checks that it is a compile-time error if an inline class has a
+/// dependency on itself.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V1<T> implements V2<T> {
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final T id;
+  V1(this.id);
+}
+
+inline class V2<T> implements V3<T> {
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final T id;
+  V2(this.id);
+}
+
+typedef V1Alias = V1<String>;
+
+inline class V3<T> implements V1Alias {
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final T id;
+  V3(this.id);
+}
+
+main() {
+  print(V1);
+  print(V2);
+  print(V3);
+}

LanguageFeatures/Inline-classes/composing_inline_classes_A03_t01.dart

@@ -0,0 +1,43 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+/// ...
+/// Assume that DV has two direct or indirect superinterface of the form
+/// W<T1, .. Tk> respectively W<S1, .. Sk>. A compile-time error occurs if Tj is
+/// not equal to Sj for any j in 1 .. k. The notion of equality used here is the
+/// same as with the corresponding rule about superinterfaces of classes.
+///
+/// @description Checks that it is a compile-time error if an inline class has
+/// two superinterfaces of the form `W<T1, .. Tk>`, `W<S1, .. Sk>` and there is
+/// a `j` such that `Tj` is not equal to `Sj`.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class I1<T1, T2> {}
+inline class I2<T1, T2> implements I1<T1, T2>{}
+
+inline class V1 implements I1<int, String>, I2<int, Object> {
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final int id;
+  V1(this.id);
+}
+
+inline class V2<T1, T2> implements I1<T1, T2>, I2<T2, T1> {
+//           ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final int id;
+  V2(this.id);
+}
+
+main() {
+  print(V1);
+  print(V2);
+}

LanguageFeatures/Inline-classes/composing_inline_classes_A04_t01.dart

@@ -0,0 +1,38 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+/// ...
+/// Assume that an inline class declaration DV named Inline has representation
+/// type R, and that the inline type V1 with declaration DV1 is a superinterface
+/// of DV (note that V1 may have some actual type arguments). Assume that S is
+/// the instantiated representation type corresponding to V1. A compile-time
+/// error occurs if R is not a subtype of S.
+///
+/// @description Checks that it is a compile-time error if an inline class has
+/// a representation type `R` and a superinterface with a representation type
+/// `S` and `R` is not a subtype of `S`
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V1 {
+  final int id;
+  V1(this.id);
+}
+
+inline class V implements V1 {
+  final num id;
+//          ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  V(this.id);
+}
+
+main() {
+  print(V1);
+  print(V);
+}

LanguageFeatures/Inline-classes/composing_inline_classes_A04_t02.dart

@@ -0,0 +1,39 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+/// ...
+/// Assume that an inline class declaration DV named Inline has representation
+/// type R, and that the inline type V1 with declaration DV1 is a superinterface
+/// of DV (note that V1 may have some actual type arguments). Assume that S is
+/// the instantiated representation type corresponding to V1. A compile-time
+/// error occurs if R is not a subtype of S.
+///
+/// @description Checks that it is a compile-time error if an inline class has
+/// a representation type `R` and a superinterface with a representation type
+/// `S` and `R` is not a subtype of `S`
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V1<T> {
+  final T id1;
+  V1(this.id1);
+}
+
+inline class V implements V1<String> {
+//           ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  final num id;
+  V(this.id);
+}
+
+main() {
+  print(V1);
+  print(V);
+}

LanguageFeatures/Inline-classes/composing_inline_classes_A04_t03.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+/// ...
+/// Assume that an inline class declaration DV named Inline has representation
+/// type R, and that the inline type V1 with declaration DV1 is a superinterface
+/// of DV (note that V1 may have some actual type arguments). Assume that S is
+/// the instantiated representation type corresponding to V1. A compile-time
+/// error occurs if R is not a subtype of S.
+///
+/// @description Checks that it is not an error if an inline class has a
+/// representation type `R` and a superinterface with a representation type `S`
+/// and `R` is a subtype of `S`
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V1<T> {
+  final T id1;
+  V1(this.id1);
+}
+
+inline class V implements V1<num> {
+  final int id;
+  V(this.id);
+}
+
+main() {
+  print(V1);
+  print(V);
+}

LanguageFeatures/Inline-classes/composing_inline_classes_A05_t01.dart

@@ -0,0 +1,47 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+/// ...
+/// A compile-time error occurs if an inline class declaration DV has two
+/// superinterfaces V1 and V2, where both V1 and V2 have a member named m, and
+/// the two declarations of m are distinct declarations, and DV does not declare
+/// a member named m.
+///
+/// @description Checks that it is a compile-time error if an inline class
+/// declaration `DV` has two superinterfaces `V1` and `V2`, where both `V1` and
+/// `V2` have a member named `m`, and the two declarations of `m` are distinct
+/// declarations, and DV does not declare a member named `m`. Test the case when
+/// members in `V1` and `V2` have different signatures
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V1 {
+  final int id;
+  V1(this.id);
+
+  int m() => 42;
+}
+
+inline class V2 {
+  final int id;
+  V2(this.id);
+
+  String m() => "42";
+}
+
+inline class V implements V1, V2 {
+//           ^
+// [analyzer] unspecified
+// [cfe] unspecified
+  final int id;
+  V(this.id);
+}
+
+main() {
+  print(V);
+}

LanguageFeatures/Inline-classes/composing_inline_classes_A05_t02.dart

@@ -0,0 +1,45 @@
+// Copyright (c) 2023, 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 Assume that DV is an inline class declaration named Inline, and
+/// V1 occurs as one of the <type>s in the <interfaces> of DV. In this case we
+/// say that V1 is a superinterface of DV.
+/// ...
+/// A compile-time error occurs if an inline class declaration DV has two
+/// superinterfaces V1 and V2, where both V1 and V2 have a member named m, and
+/// the two declarations of m are distinct declarations, and DV does not declare
+/// a member named m.
+///
+/// @description Checks that it is not an error if an inline class declaration
+/// `DV` has two superinterfaces `V1` and `V2`, where both `V1` and `V2` have a
+/// member named `m`, and the two declarations of `m` are distinct
+/// declarations, but DV does declare a member named `m`.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V1 {
+  final int id;
+  V1(this.id);
+
+  int m() => 1;
+}
+
+inline class V2 {
+  final int id;
+  V2(this.id);
+
+  int m() => 2;
+}
+
+inline class V implements V1, V2 {
+  final int id;
+  V(this.id);
+
+  num get m => 3.14;
+}
+
+main() {
+  print(V);
+}