#1400. Dynamic semantics inline class tests (#2081)

Dynamic semantics inline class tests

Author: sgrekhov

LanguageFeatures/Inline-classes/dynamic_semantics_inline_class_A01_t01.dart

@@ -0,0 +1,40 @@
+// 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 At run time, for a given instance o typed as an inline type V,
+/// there is no reification of V associated with o.
+///
+/// @description Check that the run-time type of an instance of an inline class
+/// is its representation type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class V1 {
+  final int id;
+  V1(this.id);
+}
+
+inline class V2<T> {
+  final T id;
+  V2(this.id);
+}
+
+main() {
+  var v1 = V1(42);
+  Expect.equals(int, v1.runtimeType);
+
+  int i = v1 as int;
+  Expect.equals(42, i);
+  Expect.isTrue(i.isEven);
+
+  var v2 = V2<String>("");
+  Expect.equals(String, v2.runtimeType);
+
+  String s = v2 as String;
+  Expect.equals("", s);
+  Expect.isTrue(s.isEmpty);
+}

LanguageFeatures/Inline-classes/dynamic_semantics_inline_class_A02_t01.dart

@@ -0,0 +1,36 @@
+// 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 run-time representation of a type argument which is an inline
+/// type V is the corresponding instantiated representation type.
+///
+/// @description Check that the run-time representation of a type argument which
+/// is an inline type V is the corresponding instantiated representation type.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class V1 {
+  final int id;
+  V1(this.id);
+}
+
+inline class V2<T> {
+  final T id;
+  V2(this.id);
+}
+
+main() {
+  List<V1> l1 = [];
+  Expect.equals(List<int>, l1.runtimeType);
+  (l1 as List<int>).add(42);
+  Expect.throws(() { (l1 as dynamic).add(3.14);});
+
+  List<V2<String>> l2 = [];
+  Expect.equals(List<String>, l2.runtimeType);
+  (l2 as List<String>).add("42");
+  Expect.throws(() { (l2 as dynamic).add(42);});
+}

LanguageFeatures/Inline-classes/dynamic_semantics_inline_class_A03_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 A type test, o is U or o is! U, and a type cast, o as U, where U
+/// is or contains an inline type, is performed at run time as a type test and
+/// type cast on the run-time representation of the inline type
+///
+/// @description Check that at run time a type test, `o is U` or `o is! U` is
+/// performed as a type test on the run-time representation of the inline type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class V1 {
+  final int id;
+  V1(this.id);
+}
+
+inline class V2<T> {
+  final T id;
+  V2(this.id);
+}
+
+void main() {
+  var objects = [
+    true,
+    1,
+    3.14,
+    "String",
+    #foo,
+    <String>[],
+    {'a': () {}},
+    {42,},
+    (),
+    (42,),
+    StringBuffer('Hello')
+  ];
+
+  for (var o in objects) {
+    Expect.equals(o is V1, o is int);
+    Expect.equals(o is! V1, o is! int);
+    Expect.equals(o is V2<String>, o is String);
+    Expect.equals(o is! V2<String>, o is! String);
+  }
+}

LanguageFeatures/Inline-classes/dynamic_semantics_inline_class_A03_t02.dart

@@ -0,0 +1,94 @@
+// 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 type test, o is U or o is! U, and a type cast, o as U, where U
+/// is or contains an inline type, is performed at run time as a type test and
+/// type cast on the run-time representation of the inline type
+///
+/// @description Check that at run time a type cast, `o as U` is performed as a
+/// type cast on the run-time representation of the inline type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class V1 {
+  final int id;
+  V1(this.id);
+}
+
+inline class V2<T> {
+  final T id;
+  V2(this.id);
+}
+
+bool testAsInt(Object instance) {
+  try {
+    instance as int;
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+bool testAsV1(Object instance) {
+  try {
+    instance as V1;
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+bool testAsT<T>(Object instance) {
+  try {
+    instance as T;
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+bool testAsV2<T>(Object instance) {
+  try {
+    instance as V2<T>;
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+void main() {
+  int i = 42;
+  var v1 = V1(i);
+  var v2 = V2<num>(i);
+
+  List<int> l = [];
+  var v3 = V2<List<int>>(l);
+
+  var objects = [
+    true,
+    3.14,
+    i,
+    v1,
+    v2,
+    l,
+    v3,
+    "String",
+    #foo,
+    <String>[],
+    {'a': () {}},
+    {42,},
+    (),
+    (42,),
+    StringBuffer('Hello')
+  ];
+
+  for (var o in objects) {
+    Expect.equals(testAsInt(o), testAsV1(o));
+    Expect.equals(testAsT<int>(o), testAsV2<int>(o));
+    Expect.equals(testAsT<List<int>>(o), testAsV2<List<int>>(o));
+  }
+}

LanguageFeatures/Inline-classes/dynamic_semantics_inline_class_A04_t01.dart

@@ -0,0 +1,31 @@
+// 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 An inline type V used as an expression (a type literal) evaluates
+/// to the value of the corresponding instantiated representation type used as
+/// an expression.
+///
+/// @description Check that if an inline type `V` is used as an expression then
+/// it evaluates to the value of the corresponding instantiated representation
+/// type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class V1 {
+  final int id;
+  V1(this.id);
+}
+
+inline class V2<T> {
+  final T Function(int) f;
+  V2(this.f);
+}
+
+main() {
+  Expect.equals(int, V1);
+  Expect.equals(V2<bool>, typeOf<bool Function(int)>());
+}