// 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 correctly for [typedef]
 * with two related parameters: [typedef G<X extends A<Y>, Y extends A<X>> =
 * void Function<X1 extends X, Y1 extends Y>(X, Y)]
 *
 * @Issue 41963, 41964
 *
 * @author iarkh@unipro.ru
 */

class A<X> {}
typedef G<X extends A<Y>, Y extends A<X>> =
    void Function<X1 extends X, Y1 extends Y>(X, Y);

test(G source) {

  void Function<X extends A<dynamic>, Y extends A<dynamic>>(A<dynamic>, A<dynamic>) target1 = source;

  void Function<X extends A<dynamic>, Y extends A<Never>>(A<dynamic>, A<Never>) target2 = source;
//                                                                                        ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<Never>, Y extends A<dynamic>>(A<Never>, A<dynamic>) target3 = source;
//                                                                                        ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<Never>, Y extends A<Never>>(A<Never>, A<Never>) target4 = source;
//                                                                                    ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<dynamic>, Y extends A<Null>>(A<dynamic>, A<Null>) target5 = source;
//                                                                                      ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<Null>, Y extends A<dynamic>>(A<Null>, A<dynamic>) target6 = source;
//                                                                                      ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<Null>, Y extends A<Null>>(A<Null>, A<Null>) target7 = source;
//                                                                                ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<dynamic>, Y extends dynamic>(A<dynamic>, dynamic) target8 = source;
//                                                                                      ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<dynamic>, Y extends Never>(A<dynamic>, Never) target9 = source;
//                                                                                  ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<Never>, Y extends dynamic>(A<Never>, dynamic) target10 = source;
//                                                                                   ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<Never>, Y extends Never>(A<Never>, Never) target11 = source;
//                                                                               ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<dynamic>, Y extends Null>(A<dynamic>, Null) target12 = source;
//                                                                                 ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<Null>, Y extends dynamic>(A<Null>, dynamic) target13 = source;
//                                                                                 ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends A<Null>, Y extends Null>(A<Null>, Null) target14 = source;
//                                                                           ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends dynamic, Y extends A<dynamic>>(dynamic, A<dynamic>) target15 = source;
//                                                                                       ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends dynamic, Y extends A<Never>>(dynamic, A<Never>) target16 = source;
//                                                                                   ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends Never, Y extends A<dynamic>>(Never, A<dynamic>) target17 = source;
//                                                                                   ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends Never, Y extends A<Never>>(Never, A<Never>) target18 = source;
//                                                                               ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends dynamic, Y extends A<Null>>(dynamic, A<Null>) target19 = source;
//                                                                                 ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends Null, Y extends A<dynamic>>(Null, dynamic) target20 = source;
//                                                                              ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified

  void Function<X extends Null, Y extends A<Null>>(Null, A<Null>) target21 = source;
//                                                                           ^^^^^^
// [analyzer] unspecified
// [cfe] unspecified
}

main() {}