Fixes #2383. Add more constant evaluation tests (#2396)

Add more constant evaluation tests

Author: sgrekhov

LanguageFeatures/Extension-types/static_analysis_extension_types_A20_t02.dart

@@ -0,0 +1,100 @@
+// 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 extension type erasure of an extension type V is obtained by
+/// recursively replacing every subterm of V which is an extension type by the
+/// corresponding representation type.
+///
+/// Let X1 extends B1, .. Xs extends Bs be a declaration of the type parameters
+/// of a generic entity (it could be a generic class, extension type, mixin,
+/// typedef, or function). Let BBj be the extension type erasure of
+/// Bj, for j in 1 .. s. It is a compile-time error if
+/// X1 extends BB1, .. Xs extends BBs has any compile-time errors.
+///
+/// @description Check that the erasure of an extension type `V` is obtained by
+/// recursively replacing every subterm of `V` which is an extension type by the
+/// corresponding representation type
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+extension type const Check._(Object? _) {
+  const Check(Object? object, {required Object? expected}) : _ = object,
+      assert(identical(expected, object));
+}
+
+extension type const ExtInt1(int _) implements int {}
+extension type const ExtInt2(int _) {}
+extension type const ExtString1(String _) implements String {}
+extension type const ExtString2(String _) {}
+extension type const ExtList1<T>(List<T> _) implements List<T> {}
+extension type const ExtList2<T>(List<T> _) {}
+extension type const ExtMap1<K, V>(Map<K, V> _) implements Map<K, V> {}
+extension type const ExtMap2<K, V>(Map<K, V> _) {}
+
+void main() {
+  // Base case.
+  const Check(ExtInt1, expected: int);
+  const Check(ExtInt2, expected: int);
+  // Generics.
+  const Check(ExtList1<int>, expected: List<int>);
+  const Check(ExtList2<int>, expected: List<int>);
+  const Check(List<ExtInt1>, expected: List<int>);
+  const Check(List<ExtInt2>, expected: List<int>);
+  const Check(ExtList1<ExtInt1>, expected: List<int>);
+  const Check(ExtList1<ExtInt2>, expected: List<int>);
+  const Check(ExtList2<ExtInt1>, expected: List<int>);
+  const Check(ExtList2<ExtInt2>, expected: List<int>);
+  // Multiple arguments.
+  const Check(Map<ExtInt1, String>, expected: Map<int, String>);
+  const Check(Map<ExtInt2, String>, expected: Map<int, String>);
+  const Check(Map<ExtInt1, ExtString1>, expected: Map<int, String>);
+  const Check(Map<ExtInt1, ExtString2>, expected: Map<int, String>);
+  const Check(Map<ExtInt2, ExtString1>, expected: Map<int, String>);
+  const Check(Map<ExtInt2, ExtString2>, expected: Map<int, String>);
+  const Check(ExtMap1<int, String>, expected: Map<int, String>);
+  const Check(ExtMap2<int, String>, expected: Map<int, String>);
+  const Check(ExtMap1<int, ExtString1>, expected: Map<int, String>);
+  const Check(ExtMap2<int, ExtString1>, expected: Map<int, String>);
+  const Check(ExtMap1<int, ExtString2>, expected: Map<int, String>);
+  const Check(ExtMap2<int, ExtString2>, expected: Map<int, String>);
+  const Check(ExtMap1<ExtInt1, String>, expected: Map<int, String>);
+  const Check(ExtMap1<ExtInt2, String>, expected: Map<int, String>);
+  const Check(ExtMap2<ExtInt1, String>, expected: Map<int, String>);
+  const Check(ExtMap2<ExtInt2, String>, expected: Map<int, String>);
+  const Check(ExtMap1<ExtInt1, ExtString1>, expected: Map<int, String>);
+  const Check(ExtMap1<ExtInt1, ExtString2>, expected: Map<int, String>);
+  const Check(ExtMap1<ExtInt2, ExtString2>, expected: Map<int, String>);
+  const Check(ExtMap1<ExtInt2, ExtString1>, expected: Map<int, String>);
+  const Check(ExtMap2<ExtInt1, ExtString1>, expected: Map<int, String>);
+  const Check(ExtMap2<ExtInt1, ExtString2>, expected: Map<int, String>);
+  const Check(ExtMap2<ExtInt2, ExtString2>, expected: Map<int, String>);
+  const Check(ExtMap2<ExtInt2, ExtString1>, expected: Map<int, String>);
+  // Generic twice.
+  const Check(List<List<ExtInt1>>, expected: List<List<int>>);
+  const Check(List<List<ExtInt2>>, expected: List<List<int>>);
+  const Check(List<ExtList1<int>>, expected: List<List<int>>);
+  const Check(List<ExtList2<int>>, expected: List<List<int>>);
+  const Check(ExtList1<List<int>>, expected: List<List<int>>);
+  const Check(ExtList2<List<int>>, expected: List<List<int>>);
+  const Check(ExtList1<List<ExtInt1>>, expected: List<List<int>>);
+  const Check(ExtList1<List<ExtInt2>>, expected: List<List<int>>);
+  const Check(ExtList2<List<ExtInt1>>, expected: List<List<int>>);
+  const Check(ExtList2<List<ExtInt2>>, expected: List<List<int>>);
+  const Check(List<ExtList1<ExtInt1>>, expected: List<List<int>>);
+  const Check(List<ExtList1<ExtInt2>>, expected: List<List<int>>);
+  const Check(List<ExtList2<ExtInt1>>, expected: List<List<int>>);
+  const Check(List<ExtList2<ExtInt2>>, expected: List<List<int>>);
+  const Check(ExtList1<ExtList1<int>>, expected: List<List<int>>);
+  const Check(ExtList1<ExtList2<int>>, expected: List<List<int>>);
+  const Check(ExtList2<ExtList1<int>>, expected: List<List<int>>);
+  const Check(ExtList2<ExtList2<int>>, expected: List<List<int>>);
+  const Check(ExtList1<ExtList1<ExtInt1>>, expected: List<List<int>>);
+  const Check(ExtList1<ExtList1<ExtInt2>>, expected: List<List<int>>);
+  const Check(ExtList1<ExtList2<ExtInt2>>, expected: List<List<int>>);
+  const Check(ExtList2<ExtList1<ExtInt1>>, expected: List<List<int>>);
+  const Check(ExtList2<ExtList1<ExtInt2>>, expected: List<List<int>>);
+  const Check(ExtList2<ExtList2<ExtInt2>>, expected: List<List<int>>);
+  const Check(ExtList2<ExtList2<ExtInt1>>, expected: List<List<int>>);
+}

LanguageFeatures/Extension-types/static_analysis_extension_types_A20_t03.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 The extension type erasure of an extension type V is obtained by
+/// recursively replacing every subterm of V which is an extension type by the
+/// corresponding representation type.
+///
+/// Let X1 extends B1, .. Xs extends Bs be a declaration of the type parameters
+/// of a generic entity (it could be a generic class, extension type, mixin,
+/// typedef, or function). Let BBj be the extension type erasure of
+/// Bj, for j in 1 .. s. It is a compile-time error if
+/// X1 extends BB1, .. Xs extends BBs has any compile-time errors.
+///
+/// @description Check that the erasure of an extension type `V` is obtained by
+/// recursively replacing every subterm of `V` which is an extension type by the
+/// corresponding representation type. Test function types
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+extension type const Check._(Object? _) {
+  const Check(Object? object, {required Object? expected}) : _ = object,
+      assert(identical(expected, object));
+}
+
+typedef int IntFunction(int);
+typedef T GenFunction<T>();
+typedef List<T> ListFunction<T>();
+typedef Map<K, V> MapFunction<K, V>();
+
+extension type const ExtFuncInt(IntFunction _) {}
+extension type const ExtFuncGen<T>(GenFunction<T> _) {}
+extension type const ExtFuncList<T>(ListFunction<T> _) {}
+extension type const ExtFuncMap<K, V>(MapFunction<K, V> _) {}
+
+void main() {
+  // Base case.
+  const Check(ExtFuncInt, expected: IntFunction);
+  // Generics.
+  const Check(ExtFuncGen<int>, expected: GenFunction<int>);
+  const Check(ExtFuncList<String>, expected: ListFunction<String>);
+  const Check(ExtFuncMap<String, num>, expected: MapFunction<String, num>);
+  // Multiple arguments.
+  const Check(Map<ExtFuncInt, String>, expected: Map<IntFunction, String>);
+  const Check(Map<ExtFuncInt, ExtFuncGen<String>>,
+      expected: Map<IntFunction, GenFunction<String>>);
+  const Check(ExtFuncMap<ExtFuncInt, ExtFuncGen<String>>,
+      expected: MapFunction<IntFunction, GenFunction<String>>);
+  // Generic twice.
+  const Check(List<List<ExtFuncInt>>, expected: List<List<IntFunction>>);
+  const Check(List<ExtFuncGen<int>>, expected: List<GenFunction<int>>);
+  const Check(ExtFuncGen<List<int>>, expected: GenFunction<List<int>>);
+  const Check(ExtFuncList<List<ExtFuncInt>>,
+      expected: ListFunction<List<IntFunction>>);
+  const Check(List<ExtFuncGen<ExtFuncInt>>,
+      expected: List<GenFunction<IntFunction>>);
+  const Check(ExtFuncList<ExtFuncList<int>>,
+      expected: ListFunction<ListFunction<int>>);
+  const Check(ExtFuncList<ExtFuncList<ExtFuncInt>>,
+      expected: ListFunction<ListFunction<IntFunction>>);
+}

LanguageFeatures/Extension-types/static_analysis_extension_types_A20_t04.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 The extension type erasure of an extension type V is obtained by
+/// recursively replacing every subterm of V which is an extension type by the
+/// corresponding representation type.
+///
+/// Let X1 extends B1, .. Xs extends Bs be a declaration of the type parameters
+/// of a generic entity (it could be a generic class, extension type, mixin,
+/// typedef, or function). Let BBj be the extension type erasure of
+/// Bj, for j in 1 .. s. It is a compile-time error if
+/// X1 extends BB1, .. Xs extends BBs has any compile-time errors.
+///
+/// @description Check that the erasure of an extension type `V` is obtained by
+/// recursively replacing every subterm of `V` which is an extension type by the
+/// corresponding representation type. Test function types
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+extension type const Check._(Object? _) {
+  const Check(Object? object, {required Object? expected}) : _ = object,
+      assert(identical(expected, object));
+}
+
+typedef GenFunction = X Function<X>(X x);
+typedef ListFunction = X Function<X>(List<X> v);
+typedef MapFunction = void Function<K, V>(Map<K, V> v);
+
+extension type const ExtFuncGen(GenFunction _) {}
+extension type const ExtFuncList(ListFunction _) {}
+extension type const ExtFuncMap(MapFunction _) {}
+
+void main() {
+  const Check(ExtFuncGen, expected: GenFunction);
+  const Check(ExtFuncList, expected: ListFunction);
+  const Check(ExtFuncMap, expected: MapFunction);
+
+  const Check(List<ExtFuncGen>, expected: List<GenFunction>);
+  const Check(Map<ExtFuncGen, String>, expected: Map<GenFunction, String>);
+  const Check(Map<String, ExtFuncGen>, expected: Map<String, GenFunction>);
+  const Check(Map<ExtFuncList, ExtFuncGen>,
+      expected: Map<ListFunction, GenFunction>);
+}

LanguageFeatures/Extension-types/static_analysis_extension_types_A20_t05.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 The extension type erasure of an extension type V is obtained by
+/// recursively replacing every subterm of V which is an extension type by the
+/// corresponding representation type.
+///
+/// Let X1 extends B1, .. Xs extends Bs be a declaration of the type parameters
+/// of a generic entity (it could be a generic class, extension type, mixin,
+/// typedef, or function). Let BBj be the extension type erasure of
+/// Bj, for j in 1 .. s. It is a compile-time error if
+/// X1 extends BB1, .. Xs extends BBs has any compile-time errors.
+///
+/// @description Check that the erasure of an extension type `V` is obtained by
+/// recursively replacing every subterm of `V` which is an extension type by the
+/// corresponding representation type. Test function types
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+extension type const Check._(Object? _) {
+  const Check(Object? object, {required Object? expected}) : _ = object,
+    assert(identical(expected, object));
+}
+
+extension type const ExtInt(int _) {}
+
+typedef ExtIntFunc1 = ExtInt Function(ExtInt _, [ExtInt __]);
+typedef ExtIntFunc2 = ExtInt Function(ExtInt _, {ExtInt n});
+typedef ExtIntFunc3 = ExtInt Function(ExtInt _, {required ExtInt n});
+
+typedef IntFunc1 = int Function(int _, [int __]);
+typedef IntFunc2 = int Function(int _, {int n});
+typedef IntFunc3 = int Function(int _, {required int n});
+
+void main() {
+  const Check(ExtIntFunc1, expected: IntFunc1);
+  const Check(ExtIntFunc2, expected: IntFunc2);
+  const Check(ExtIntFunc3, expected: IntFunc3);
+}

LanguageFeatures/Extension-types/static_analysis_extension_types_A20_t06.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 The extension type erasure of an extension type V is obtained by
+/// recursively replacing every subterm of V which is an extension type by the
+/// corresponding representation type.
+///
+/// Let X1 extends B1, .. Xs extends Bs be a declaration of the type parameters
+/// of a generic entity (it could be a generic class, extension type, mixin,
+/// typedef, or function). Let BBj be the extension type erasure of
+/// Bj, for j in 1 .. s. It is a compile-time error if
+/// X1 extends BB1, .. Xs extends BBs has any compile-time errors.
+///
+/// @description Check that the erasure of an extension type `V` is obtained by
+/// recursively replacing every subterm of `V` which is an extension type by the
+/// corresponding representation type. Test function types
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+extension type const Check._(Object? _) {
+  const Check(Object? object, {required Object? expected}) : _ = object,
+    assert(identical(expected, object));
+}
+
+extension type const ExtInt(int _) {}
+extension type const ExtList<T>(List<T> _) {}
+
+typedef ExtListFunc1 = ExtList<ExtInt> Function(ExtList<ExtInt> _,
+    [ExtList<ExtInt> __]);
+typedef ExtListFunc2 = ExtList<ExtInt> Function(ExtList<ExtInt> _,
+    {ExtList<ExtInt> n});
+typedef ExtListFunc3 = ExtList<ExtInt> Function(ExtList<ExtInt> _,
+    {required ExtList<ExtInt> n});
+
+typedef ErasedFunc1 = List<int> Function(List<int> _, [List<int> __]);
+typedef ErasedFunc2 = List<int> Function(List<int> _, {List<int> n});
+typedef ErasedFunc3 = List<int> Function(List<int> _, {required List<int> n});
+
+void main() {
+  const Check(ExtListFunc1, expected: ErasedFunc1);
+  const Check(ExtListFunc2, expected: ErasedFunc2);
+  const Check(ExtListFunc3, expected: ErasedFunc3);
+}