#1400. Static analysis of inline class tests. Part 1 (#2058)

Add tests about the static analysis of inline classes. Part 1

Author: sgrekhov

LanguageFeatures/Inline-classes/static_analysis_inline_class_A01_t01.dart

@@ -0,0 +1,32 @@
+// 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 The unique instance variable declared by an inline class must
+/// have a type annotation.
+///
+/// @description Checks that it is a compile-time error if an instance variable
+/// of the inline class has no type annotation
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class IC1 {
+  final id;
+//      ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  IC1(this.id);
+}
+
+inline class IC2 {
+  final id = 42;
+//      ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  IC1 ic1 = IC1(42);
+  IC2 ic2 = IC2();
+}

LanguageFeatures/Inline-classes/static_analysis_inline_class_A02_t01.dart

@@ -0,0 +1,54 @@
+// 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 T1, .. Ts are types, and V resolves to an inline
+/// class declaration of the following form:
+///
+/// inline class V<X1 extends B1, .. Xs extends Bs> ... {
+///   final T id;
+///   V(this.id);
+///
+///   ... // Other members.
+/// }
+/// It is then allowed to use V<T1, .. Ts> as a type.
+///
+/// @description Checks that `V<T1, .. Ts>` can be used as a type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class V<X1 extends num, X2 extends Object> {
+  final X1 id;
+  V(this.id);
+}
+
+V<int, int> foo(V<int, int> v) => v;
+
+class C<T extends V<num, Object>> {
+  V<int, int> bar<T extends V<num, num>>(T t) => t as V<int, int>;
+}
+
+main() {
+  V v1 = V(42);
+  Expect.isTrue(v1 is V<num, Object>);
+  Expect.isTrue(v1 is V<num, Never>);
+  Expect.isTrue(v1 is V<int, String>);
+
+  V<int, int> v2 = V(42);
+  Expect.isTrue(v2 is V<int, int>);
+
+  V<num, Object> v3 = V<int, Never>(42);
+  Expect.isTrue(v3 is V<num, Object>);
+
+  List<V> l1 = List.empty();
+  Expect.isTrue(l1 is List<V<num, Object>>);
+
+  List<V<num, double>> l2 = List.empty();
+  Expect.isTrue(l2 is List<V<num, double>>);
+
+  foo(v2);
+  C<V<int, int>>().bar<V<int, int>>(v2);
+}

LanguageFeatures/Inline-classes/static_analysis_inline_class_A02_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 T1, .. Ts are types, and V resolves to an inline
+/// class declaration of the following form:
+///
+/// inline class V<X1 extends B1, .. Xs extends Bs> ... {
+///   final T id;
+///   V(this.id);
+///
+///   ... // Other members.
+/// }
+/// It is then allowed to use V<T1, .. Ts> as a type.
+///
+/// @description Checks that an inline type `V<T1, .. Ts>` can be used in a
+/// function types and type aliases
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class V<X1 extends num, X2 extends Object> {
+  final X1 id;
+  V(this.id);
+}
+
+typedef V<int, int> Foo<T extends V<num, Object>>(V<int, int> v);
+typedef IntNumV = V<int, num>;
+
+V<int, int> foo<T extends V<num, Object>>(T t) => t as V<int, int>;
+
+class C<T extends V<num, Object>> {
+   Foo<T> f = foo<V<int, int>>;
+}
+
+main() {
+  IntNumV v = IntNumV(42);
+  Expect.equals(42, v.id);
+
+  Expect.equals(v, foo(v));
+  Expect.equals(V<int, int>(0), C<V<int, int>>().f(V<int, int>(0)));
+  Expect.equals(V(1), C<V<int, int>>().f(V<int, int>(1)));
+}

LanguageFeatures/Inline-classes/static_analysis_inline_class_A03_t01.dart

@@ -0,0 +1,49 @@
+// 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 T1, .. Ts are types, and V resolves to an inline
+/// class declaration of the following form:
+///
+/// inline class V<X1 extends B1, .. Xs extends Bs> ... {
+///   final T id;
+///   V(this.id);
+///
+///   ... // Other members.
+/// }
+/// ...
+/// A compile-time error occurs if the type V<T1, .. Ts> is not regular-bounded.
+///
+/// @description Checks that it is a compile-time error if the type
+/// `V<T1, .. Ts>` is not regular-bounded.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+class A {}
+class B extends A {}
+class C extends B {}
+
+inline class V<X1 extends num, X2 extends B> {
+  final X1 id;
+  V(this.id);
+
+  X2 foo() => id as X2;
+}
+
+main() {
+  V<int, Object?> v1 = V(42);
+//       ^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  V<String, B> v2 = V("42");
+//  ^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  <V<num, A>>[];
+//        ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Inline-classes/static_analysis_inline_class_A03_t02.dart

@@ -0,0 +1,33 @@
+// 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 T1, .. Ts are types, and V resolves to an inline
+/// class declaration of the following form:
+///
+/// inline class V<X1 extends B1, .. Xs extends Bs> ... {
+///   final T id;
+///   V(this.id);
+///
+///   ... // Other members.
+/// }
+/// ...
+/// A compile-time error occurs if the type V<T1, .. Ts> is not regular-bounded.
+///
+/// @description Checks that it is a compile-time error if the type
+/// `V<T1, .. Ts>` is not regular-bounded.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V<T extends V<T>> {
+  final T id;
+  V(this.id);
+}
+
+main() {
+  List<V> l = [];
+//     ^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Inline-classes/static_analysis_inline_class_A04_t01.dart

@@ -0,0 +1,24 @@
+// 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 A compile-time error occurs if a type parameter of an inline
+/// class occurs in a non-covariant position in the representation type.
+///
+/// @description Checks that it is a compile-time error if a type parameter of
+/// an inline class occurs in a non-covariant position in the representation
+/// type
+/// @author [email protected]
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V<T extends num> {
+  final void Function(T) f;
+//                    ^
+// [analyzer] unspecified
+// [cfe] unspecified
+  V(this.f);
+}
+
+main() {
+  print(V);
+}

LanguageFeatures/Inline-classes/static_analysis_inline_class_A05_t01.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 T1, .. Ts are types, and V resolves to an inline
+/// class declaration of the following form:
+///
+/// inline class V<X1 extends B1, .. Xs extends Bs> ... {
+///   final T id;
+///   V(this.id);
+///
+///   ... // Other members.
+/// }
+/// ...
+/// When s is zero, V<T1, .. Ts> simply stands for V, a non-generic inline type.
+/// When s is greater than zero, a raw occurrence V is treated like a raw type:
+/// Instantiation to bound is used to obtain the omitted type arguments
+///
+/// @description Checks that instantiation to bound is used to obtain the
+/// omitted type arguments
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/static_type_helper.dart";
+
+class A {}
+class B extends A {}
+class C extends B {}
+
+inline class V<T1 extends num, T2 extends B> {
+  final T1 id;
+  V(this.id);
+}
+
+main() {
+  num n = 42;
+  V(n).expectStaticType<Exactly<V<num, B>>>();
+}

LanguageFeatures/Inline-classes/static_analysis_inline_class_A05_t02.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 T1, .. Ts are types, and V resolves to an inline
+/// class declaration of the following form:
+///
+/// inline class V<X1 extends B1, .. Xs extends Bs> ... {
+///   final T id;
+///   V(this.id);
+///
+///   ... // Other members.
+/// }
+/// ...
+/// When s is zero, V<T1, .. Ts> simply stands for V, a non-generic inline type.
+/// When s is greater than zero, a raw occurrence V is treated like a raw type:
+/// Instantiation to bound is used to obtain the omitted type arguments
+///
+/// @description Checks that instantiation to bound is used to obtain the
+/// omitted type arguments
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/static_type_helper.dart";
+
+ class V<X extends List<Y>, Y extends num> {
+  final Y id;
+  V(this.id);
+}
+
+main() {
+  List<V> l = [];
+  l.expectStaticType<Exactly<List<V<List<num>, num>>>>();
+}

LanguageFeatures/Inline-classes/static_analysis_inline_class_A06_t01.dart

@@ -0,0 +1,59 @@
+// 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 It is a compile-time error if await e occurs, and the static type
+/// of e is an inline type.
+///
+/// @description Checks that it is a compile-time error if `await e` occurs, and
+/// the static type of `e` is an inline type.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+inline class V1 {
+  final int id;
+  V(this.id);
+}
+
+inline class V2<T> {
+  final T id;
+  V(this.id);
+}
+
+inline class V3<T extends num> {
+  final T id;
+  V(this.id);
+}
+
+main() async {
+  V1 v1 = V1(42);
+  await v1;
+//      ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  V2<String> v2_1 = V2("42");
+  await v2_1;
+//      ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  V2 v2_2 = V2("42");
+  await v2_2;
+//      ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  V3<int> v3_1 = V3(42);
+  await v3_1;
+//      ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  V3 v3_2 = V3(42);
+  await v3_2;
+//      ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}