typedef F<X> = void Function<Y extends X>();

F<X> toF<X>(X x) => throw '';

typedef Fcov<X> = X Function();

typedef Fcon<X> = Function(X);

typedef Finv<X> = X Function(X);

class Acov<X extends Fcov<Y>, Y> {}

class Acon<X extends Fcon<Y>, Y> {}

class Ainv<X extends Finv<Y>, Y> {}

typedef FcovBound<X extends num> = X Function();

typedef FconBound<X extends num> = Function(X);

typedef FinvBound<X extends num> = X Function(X);

class AcovBound<X extends FcovBound<Y>, Y extends num> {}

class AconBound<X extends FconBound<Y>, Y extends num> {}

class AinvBound<X extends FinvBound<Y>, Y extends num> {}

class A<X> {}

typedef FcovCyclicBound<X extends A<X>> = X Function();

typedef FconCyclicBound<X extends A<X>> = Function(X);

typedef FinvCyclicBound<X extends A<X>> = X Function(X);

class AcovCyclicBound<X extends FcovCyclicBound<Y>, Y extends A<Y>> {}

class AconCyclicBound<X extends FconCyclicBound<Y>, Y extends A<Y>> {}

class AinvCyclicBound<X extends FinvCyclicBound<Y>, Y extends A<Y>> {}

typedef FcovCyclicCoBound<X extends Function(X)> = X Function();

typedef FconCyclicCoBound<X extends Function(X)> = Function(X);

typedef FinvCyclicCoBound<X extends Function(X)> = X Function(X);

class AcovCyclicCoBound<
  X extends FcovCyclicCoBound<Y>,
  Y extends Function(Y)
> {}

class AconCyclicCoBound<
  X extends FconCyclicCoBound<Y>,
  Y extends Function(Y)
> {}

class AinvCyclicCoBound<
  X extends FinvCyclicCoBound<Y>,
  Y extends Function(Y)
> {}

class B<X> {}

void testTypeAliasAsTypeArgument(
  Acov source1,
  Acon source2,
  Ainv source3,
  AcovBound source4,
  AconBound source5,
  AinvBound source6,
  AcovCyclicBound source7,
  AconCyclicBound source8,
  AcovCyclicCoBound source10,
  AconCyclicCoBound source11,
) {}

void testNested(
  B<Acov> source1,
  B<Acon> source2,
  B<Ainv> source3,
  B<AcovBound> source4,
  B<AconBound> source5,
  B<AinvBound> source6,
  B<AcovCyclicBound> source7,
  B<AconCyclicBound> source8,
  B<AcovCyclicCoBound> source10,
  B<AconCyclicCoBound> source11,
) {}

main() {}