Fixes #996: new tests for i-2-b and least-and-greatest-closures added.

Author: iarkh

LanguageFeatures/Generic-functions-as-type-args/Least_greatest_closure_t02.dart

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020, 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 definitions of least and greatest closure are changed in null
+ * safe libraries to substitute [Never] in positions where previously [Null
+ * would have been substituted, and [Object?] in positions where previously
+ * [Object] or [dynamic] would have been substituted.
+ * @description Check statically that correct type is substituted for generic
+ * [void Function<T>()] typedef.
+ * @note Read more about the least and greatest closure test template:
+ * https://github.com/dart-lang/co19/issues/575#issuecomment-613542349
+ *
+ * @author [email protected]
+ */
+// SharedOptions=--enable-experiment=generic-metadata
+
+import "../../Utils/expect.dart";
+
+typedef check = void Function<T>();
+
+void main() {
+  void f(check Function<T>() g) => g();
+
+  // Verify that we can call the function with the specified arguments.
+  f(<T>() => captureTypeArgument()..call());
+
+ // Verify that a couple of wrong argument lists are rejected.
+  f(<T>() => captureTypeArgument()..call(throw 1));
+  //                                     ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+
+  f(<T>() => captureTypeArgument()..call('Hello'));
+  //                                     ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+
+  f(<T>() => captureTypeArgument()..call(arg: 'Hello'));
+  //                                     ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+
+  // Verify that the return type is `void`: Returned value not usable,
+  // not even to access a member of `Object`.
+  f(<T>() => captureTypeArgument()..call().toString());
+  //                                ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}

LanguageFeatures/Generic-functions-as-type-args/i2b_A01_t01.dart

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2018, 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 Instantiate to bound then computes an actual type argument list
+ * for [G] as follows:
+ *
+ *   Let [Ui],[1] be [Si], for all [i] in [1 .. k]. (This is the "current value"
+ *   of the bound for type variable [i], at step [1]; in general we will
+ *   consider the current step, [m], and use data for that step, e.g., the bound
+ *   [Ui],[m], to compute the data for step [m + 1]).
+ *
+ *   Let [-->m] be a relation among the type variables [X1 .. Xk] such that
+ *   [Xp -->m Xq] iff [Xq] occurs in [Up],[m] (so each type variable is related
+ *   to, that is, depends on, every type variable in its bound, possibly
+ *   including itself). Let [==>m] be the transitive closure of [-->m]. For each
+ *   [m], let [Ui],[m+1], for [i] in [1 .. k], be determined by the following
+ *   iterative process:
+ *
+ *   1. If there exists a [j] in [1 .. k] such that [Xj ==>m X0j] (that is, if
+ *   the dependency graph has a cycle) let [M1 .. Mp] be the strongly connected
+ *   components (SCCs) with respect to [-->m] (that is, the maximal subsets of
+ *   [X1 .. Xk] where every pair of variables in each subset are related in both
+ *   directions by [==>m]; note that the SCCs are pairwise disjoint; also, they
+ *   are uniquely defined up to reordering, and the order does not matter). Let
+ *   [M] be the union of [M1 .. Mp] (that is, all variables that participate in
+ *   a dependency cycle). Let [i] be in [1 .. k]. If [Xi] does not belong to [M]
+ *   then [Ui,m+1 = Ui,m]. Otherwise there exists a [q] such that [Xi] belongs
+ *   to [Mq]; [Ui,m+1] is then obtained from [Ui,m] by replacing every covariant
+ *   occurrence of a variable in [Mq] by [dynamic], and replacing every
+ *   contravariant occurrence of a variable in [Mq] by [Null].
+ *
+ *   2. Otherwise, (if no dependency cycle exists) let [j] be the lowest number
+ *   such that [Xj] occurs in [Up,m] for some [p] and [Xj -/->m Xq] for all [q]
+ *   in [1..k] (that is, [Uj,m] is closed, that is, the current bound of [Xj]
+ *   does not contain any type variables; but [Xj] is being depended on by the
+ *   bound of some other type variable). Then, for all [i] in [1 .. k], [Ui,m+1]
+ *   is obtained from [Ui,m] by replacing every covariant occurrence of [Xj] by
+ *   [Uj,m], and replacing every contravariant occurrence of [Xj] by [Null].
+ *
+ *   3. Otherwise, (when no dependencies exist) terminate with the result
+ *   [<U1,m ..., Uk,m>].
+ * @description Checks that function type argument cannot have reference to
+ * itself.
+ * @author [email protected]
+ */
+// SharedOptions=--enable-experiment=generic-metadata
+
+typedef FUNC1<T> = void Function<T1 extends FUNC1<T>>();
+//                                          ^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+typedef FUNC2<T> = T2 Function<T2 extends FUNC2<T>>();
+//                                        ^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+main() {}

LanguageFeatures/Generic-functions-as-type-args/i2b_A01_t02.dart

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018, 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 Instantiate to bound then computes an actual type argument list
+ * for [G] as follows:
+ *
+ *   Let [Ui],[1] be [Si], for all [i] in [1 .. k]. (This is the "current value"
+ *   of the bound for type variable [i], at step [1]; in general we will
+ *   consider the current step, [m], and use data for that step, e.g., the bound
+ *   [Ui],[m], to compute the data for step [m + 1]).
+ *
+ *   Let [-->m] be a relation among the type variables [X1 .. Xk] such that
+ *   [Xp -->m Xq] iff [Xq] occurs in [Up],[m] (so each type variable is related
+ *   to, that is, depends on, every type variable in its bound, possibly
+ *   including itself). Let [==>m] be the transitive closure of [-->m]. For each
+ *   [m], let [Ui],[m+1], for [i] in [1 .. k], be determined by the following
+ *   iterative process:
+ *
+ *   1. If there exists a [j] in [1 .. k] such that [Xj ==>m X0j] (that is, if
+ *   the dependency graph has a cycle) let [M1 .. Mp] be the strongly connected
+ *   components (SCCs) with respect to [-->m] (that is, the maximal subsets of
+ *   [X1 .. Xk] where every pair of variables in each subset are related in both
+ *   directions by [==>m]; note that the SCCs are pairwise disjoint; also, they
+ *   are uniquely defined up to reordering, and the order does not matter). Let
+ *   [M] be the union of [M1 .. Mp] (that is, all variables that participate in
+ *   a dependency cycle). Let [i] be in [1 .. k]. If [Xi] does not belong to [M]
+ *   then [Ui,m+1 = Ui,m]. Otherwise there exists a [q] such that [Xi] belongs
+ *   to [Mq]; [Ui,m+1] is then obtained from [Ui,m] by replacing every covariant
+ *   occurrence of a variable in [Mq] by [dynamic], and replacing every
+ *   contravariant occurrence of a variable in [Mq] by [Null].
+ *
+ *   2. Otherwise, (if no dependency cycle exists) let [j] be the lowest number
+ *   such that [Xj] occurs in [Up,m] for some [p] and [Xj -/->m Xq] for all [q]
+ *   in [1..k] (that is, [Uj,m] is closed, that is, the current bound of [Xj]
+ *   does not contain any type variables; but [Xj] is being depended on by the
+ *   bound of some other type variable). Then, for all [i] in [1 .. k], [Ui,m+1]
+ *   is obtained from [Ui,m] by replacing every covariant occurrence of [Xj] by
+ *   [Uj,m], and replacing every contravariant occurrence of [Xj] by [Null].
+ *
+ *   3. Otherwise, (when no dependencies exist) terminate with the result
+ *   [<U1,m ..., Uk,m>].
+ * @description Checks that instantiate-to-bounds works as expected for  class
+ * with generic function type argument.
+ * @author [email protected]
+ */
+// SharedOptions=--enable-experiment=generic-metadata
+
+typedef FUNC<T> = void Function<T1 extends T>();
+class A<X extends FUNC<X>> {}
+
+typedef exp = void Function<T>();
+
+testme(A a) {
+//       ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+  A<exp> a1 = a;
+//       ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
+
+main() {
+  A();
+//^
+// [analyzer] unspecified
+// [cfe] unspecified
+}

LanguageFeatures/Generic-functions-as-type-args/least_greatest_closure_t01.dart

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020, 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 definitions of least and greatest closure are changed in null
+ * safe libraries to substitute [Never] in positions where previously [Null
+ * would have been substituted, and [Object?] in positions where previously
+ * [Object] or [dynamic] would have been substituted.
+ * @description Check that correct type is substituted for generic
+ * [void Function<T>()] typedef.
+ * @note Read more about the least and greatest closure test template:
+ * https://github.com/dart-lang/co19/issues/575#issuecomment-613542349
+ *
+ * $Issue 45763
+ *
+ * @author [email protected]
+ */
+// SharedOptions=--enable-experiment=generic-metadata
+
+import "../../Utils/expect.dart";
+
+typedef check = void Function<T>();
+
+void main() {
+  void f(check Function<T>() g) => g();
+  Expect.throws(() { f(<T>() => captureTypeArgument()); });
+  Expect.equals(typeOf<void Function<T>()>(), capturedTypeArgument);
+}

LanguageFeatures/Instantiate-to-bound/class/static/class_typedef_l1_t03.dart

@@ -50,7 +50,6 @@
  *
  * @author [email protected]
  */
-import "../../../../Utils/expect.dart";
 
 typedef G<X> = X Function(X);
 class A<X extends G<A<X>>> {}