#1400. Dynamic Semantics of an Inline Member Invocation tests (#2053)

Add tests on the dynamic semantics of an Inline member invocation

Author: sgrekhov

LanguageFeatures/Inline-classes/dynamic_semantics_member_invocation_A01_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 Consider an invocation of the inline member m on the receiver e
+/// according to the inline type V and with actual type arguments T1, ..., Ts.
+/// If the invocation includes an actual argument part (possibly including some
+/// actual type arguments) then call it args. Assume that V declares the type
+/// variables X1, ..., Xs.
+///
+/// Let Dm be the declaration named m thath V has.
+///
+/// Evaluation of this invocation proceeds by evaluating e to an object o.
+///
+/// Then, if args is omitted and Dm is a getter, execute the body of said
+/// getter in an environment where this and the name of the representation are
+/// bound to o, and the type variables of V are bound to the actual values of
+/// T1, .. Ts. If the body completes returning an object o2 then the invocation
+/// evaluates to o2. If the body throws an object and a stack trace then the
+/// invocation completes throwing the same object and stack trace.
+///
+/// @description Check invocation of an inline class getter. Test that if the
+/// body completes returning an object `o2` then the invocation evaluates to
+/// `o2`.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+import "../../Utils/static_type_helper.dart";
+
+inline class IC<T> {
+  final T id;
+  IC(this.id);
+}
+
+inline class IC2<T extends num> {
+  final T id;
+  IC2(this.id);
+
+  List<T> get emptyList => <T>[];
+}
+
+main() {
+  IC<Object?> ic1_1 = IC(42);
+  Expect.equals(42, ic1_1.id);
+
+  IC<Object?> ic1_2 = IC("42");
+  Expect.equals("42", ic1_2.id);
+
+  IC2<int> ic2_1 = IC2(42);
+  ic2_1.emptyList.expectStaticType<Exactly<List<int>>>();
+  Expect.throws(() {ic2_1.emptyList.add(3.14 as dynamic);});
+
+  IC2<num> ic2_2 = IC2(3.14);
+  ic2_2.emptyList.expectStaticType<Exactly<List<num>>>();
+  ic2_2.emptyList.add(42);
+  ic2_2.emptyList.add(3.14);
+}

LanguageFeatures/Inline-classes/dynamic_semantics_member_invocation_A01_t02.dart

@@ -0,0 +1,62 @@
+// 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 Consider an invocation of the inline member m on the receiver e
+/// according to the inline type V and with actual type arguments T1, ..., Ts.
+/// If the invocation includes an actual argument part (possibly including some
+/// actual type arguments) then call it args. Assume that V declares the type
+/// variables X1, ..., Xs.
+///
+/// Let Dm be the declaration named m thath V has.
+///
+/// Evaluation of this invocation proceeds by evaluating e to an object o.
+///
+/// Then, if args is omitted and Dm is a getter, execute the body of said
+/// getter in an environment where this and the name of the representation are
+/// bound to o, and the type variables of V are bound to the actual values of
+/// T1, .. Ts. If the body completes returning an object o2 then the invocation
+/// evaluates to o2. If the body throws an object and a stack trace then the
+/// invocation completes throwing the same object and stack trace.
+///
+/// @description Check invocation of an inline class getter in the case when
+/// type arguments are omitted. Test that if the body throws an object and a
+/// stack trace then the invocation completes throwing the same object and stack
+/// trace
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+StackTrace st = StackTrace.fromString("42");
+
+inline class IC<T extends num> {
+  final T id;
+  IC(this.id);
+
+  T get testMe {
+    if (2 > 1) {
+      Error.throwWithStackTrace("T is $T", st);
+    }
+    return id;
+  }
+}
+
+main() {
+  IC<num> ic1 = IC(42);
+  try {
+    ic1.testMe;
+  } catch (e, _st) {
+    Expect.equals("T is num", e);
+    Expect.equals(st, _st);
+  }
+
+  IC<int> ic2 = IC(42);
+  try {
+    ic2.testMe;
+  } catch (e, _st) {
+    Expect.equals("T is int", e);
+    Expect.equals(st, _st);
+  }
+}

LanguageFeatures/Inline-classes/dynamic_semantics_member_invocation_A02_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 Consider an invocation of the inline member m on the receiver e
+/// according to the inline type V and with actual type arguments T1, ..., Ts.
+/// If the invocation includes an actual argument part (possibly including some
+/// actual type arguments) then call it args. Assume that V declares the type
+/// variables X1, ..., Xs.
+///
+/// Let Dm be the declaration named m thath V has.
+///
+/// Evaluation of this invocation proceeds by evaluating e to an object o.
+/// ...
+/// Otherwise, if args is omitted and Dm is a method, the invocation evaluates
+/// to a closurization of Dm where this and the name of the representation are
+/// bound to o, and the type variables of V are bound to the actual values of
+/// T1, .. Ts. The operator == of the closurization returns true if and only if
+/// the operand is the same object.
+///
+/// @description Check that in case of invocation of an inline class method with
+/// the omitted type argument the actual type variables of V are bound to the
+/// actual values of T1, .. Ts.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class IC<T> {
+  final T id;
+  IC(this.id);
+
+  Map<K, Type> asMap<K, V extends T>(K key1, K key2) => {key1: V, key2: T};
+}
+
+main() {
+  IC<num> ic1_1 = IC(42);
+  Expect.mapEquals({"key1": num, "key2": num}, ic1_1.asMap("key1", "key2"));
+}

LanguageFeatures/Inline-classes/dynamic_semantics_member_invocation_A02_t02.dart

@@ -0,0 +1,42 @@
+// 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 Consider an invocation of the inline member m on the receiver e
+/// according to the inline type V and with actual type arguments T1, ..., Ts.
+/// If the invocation includes an actual argument part (possibly including some
+/// actual type arguments) then call it args. Assume that V declares the type
+/// variables X1, ..., Xs.
+///
+/// Let Dm be the declaration named m thath V has.
+///
+/// Evaluation of this invocation proceeds by evaluating e to an object o.
+/// ...
+/// Otherwise, if args is omitted and Dm is a method, the invocation evaluates
+/// to a closurization of Dm where this and the name of the representation are
+/// bound to o, and the type variables of V are bound to the actual values of
+/// T1, .. Ts. The operator == of the closurization returns true if and only if
+/// the operand is the same object.
+///
+/// @description Check that `this` is bound to `o`
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class IC<T> {
+  final T id;
+  IC(this.id);
+
+  Object test1() => this;
+  void test2() {
+    Expect.identical(this, id);
+  }
+}
+
+main() {
+  IC ic = IC(42);
+  Expect.identical(ic, ic.test1());
+  ic.test2();
+}

LanguageFeatures/Inline-classes/dynamic_semantics_member_invocation_A02_t03.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 Consider an invocation of the inline member m on the receiver e
+/// according to the inline type V and with actual type arguments T1, ..., Ts.
+/// If the invocation includes an actual argument part (possibly including some
+/// actual type arguments) then call it args. Assume that V declares the type
+/// variables X1, ..., Xs.
+///
+/// Let Dm be the declaration named m thath V has.
+///
+/// Evaluation of this invocation proceeds by evaluating e to an object o.
+/// ...
+/// Otherwise, if args is omitted and Dm is a method, the invocation evaluates
+/// to a closurization of Dm where this and the name of the representation are
+/// bound to o, and the type variables of V are bound to the actual values of
+/// T1, .. Ts. The operator == of the closurization returns true if and only if
+/// the operand is the same object.
+///
+/// @description Check that the operator `==` of the closurization returns true
+/// if and only if the operand is the same object
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class IC<T> {
+  final T id;
+  IC(this.id);
+
+  Map<K, V> asMap<K, V extends T>(K key) => {key: this.id as V};
+}
+
+main() {
+  IC<int> ic1 = IC(42);
+  var asMapTearOff = ic1.asMap;
+  Expect.notEquals(asMapTearOff, ic1.asMap);
+  Expect.equals(asMapTearOff, asMapTearOff);
+
+  IC<num> ic2 = IC(42);
+  var asMapTearOff2 = ic2.asMap;
+  Expect.notEquals(asMapTearOff2, ic2.asMap);
+  Expect.notEquals(asMapTearOff2, asMapTearOff);
+  Expect.equals(asMapTearOff2, asMapTearOff2);
+}

LanguageFeatures/Inline-classes/dynamic_semantics_member_invocation_A02_t04.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 Consider an invocation of the inline member m on the receiver e
+/// according to the inline type V and with actual type arguments T1, ..., Ts.
+/// If the invocation includes an actual argument part (possibly including some
+/// actual type arguments) then call it args. Assume that V declares the type
+/// variables X1, ..., Xs.
+///
+/// Let Dm be the declaration named m thath V has.
+///
+/// Evaluation of this invocation proceeds by evaluating e to an object o.
+/// ...
+/// Otherwise, if args is omitted and Dm is a method, the invocation evaluates
+/// to a closurization of Dm where this and the name of the representation are
+/// bound to o, and the type variables of V are bound to the actual values of
+/// T1, .. Ts. The operator == of the closurization returns true if and only if
+/// the operand is the same object.
+///
+/// @description Check that if the body throws an object and a stack trace then
+/// the invocation completes throwing the same object and stack trace.
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+StackTrace st = StackTrace.fromString("42");
+
+inline class IC<T extends num> {
+  final T id;
+  IC(this.id);
+
+  X testMe<X extends T>() {
+    if (2 > 1) {
+      Error.throwWithStackTrace("X is $X", st);
+    }
+    return id as X;
+  }
+}
+
+main() {
+  IC<num> ic1 = IC(42);
+  try {
+    ic1.testMe();
+  } catch (e, _st) {
+    Expect.equals("X is num", e);
+    Expect.equals(st, _st);
+  }
+
+  IC<int> ic2 = IC(42);
+  try {
+    ic2.testMe();
+  } catch (e, _st) {
+    Expect.equals("X is int", e);
+    Expect.equals(st, _st);
+  }
+}

LanguageFeatures/Inline-classes/dynamic_semantics_member_invocation_A03_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 Consider an invocation of the inline member m on the receiver e
+/// according to the inline type V and with actual type arguments T1, ..., Ts.
+/// If the invocation includes an actual argument part (possibly including some
+/// actual type arguments) then call it args. Assume that V declares the type
+/// variables X1, ..., Xs.
+///
+/// Let Dm be the declaration named m thath V has.
+///
+/// Evaluation of this invocation proceeds by evaluating e to an object o.
+/// ...
+/// Otherwise, the following is known: args is included, and Dm is a method. The
+/// invocation proceeds to evaluate args to an actual argument list args1. Then
+/// it executes the body of Dm in an environment where this and the name of the
+/// representation are bound to o, the type variables of V are bound to the
+/// actual values of T1, .. Ts, and the formal parameters of m are bound to
+/// args1 in the same way that they would be bound for a normal function call.
+/// If the body completes returning an object o2 then the invocation evaluates
+/// to o2. If the body throws an object and a stack trace then the invocation
+/// completes throwing the same object and stack trace.
+///
+/// @description Check that in case of an invocation of an inline class method
+/// `m` the specified type parameters and formal parameters of `m` are bound to
+/// `args1` in the same way that they would be bound for a normal function call
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+inline class IC<T> {
+  final T id;
+  IC(this.id);
+
+  Map<K, Type> asMap<K, V extends T>(K key1, K key2) => {key1: V, key2: T};
+}
+
+main() {
+  IC<num> ic1 = IC(42);
+  Expect.mapEquals(
+      {"key1": int, "key2": num}, ic1.asMap<String, int>("key1", "key2"));
+  Expect.mapEquals(
+      {"key1": num, "key2": num}, ic1.asMap<String, num>("key1", "key2"));
+}