tests/language/variance/variance_out_subtyping_test.dart

// Copyright (c) 2019, 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.

// Tests subtyping for the `out` variance modifier.

// SharedOptions=--enable-experiment=variance

import "package:expect/expect.dart";

class Covariant<out T> {}

class Upper {}
class Middle extends Upper {}
class Lower extends Middle {}

class A {
  Covariant<Middle> method1() {
    return new Covariant<Middle>();
  }

  void method2(Covariant<Middle> x) {}
}

class B extends A {
  @override
  Covariant<Lower> method1() {
    return new Covariant<Lower>();
  }

  @override
  void method2(Covariant<Upper> x) {}
}

class C extends A {
  @override
  Covariant<Middle> method1() {
    return new Covariant<Middle>();
  }

  @override
  void method2(Covariant<Middle> x) {}
}

class D<out T extends Covariant<Middle>> {}

class E {
  D<Covariant<Lower>> method1() {
    return D<Covariant<Lower>>();
  }
}

class F {
  D<Covariant<Middle>> method1() {
    return D<Covariant<Middle>>();
  }
}

void testCall(Iterable<Covariant<Middle>> x) {}

main() {
  A a = new A();
  Expect.type<Covariant<Middle>>(a.method1());
  Expect.type<Covariant<Upper>>(a.method1());
  Expect.notType<Covariant<Lower>>(a.method1());
  a.method2(new Covariant<Middle>());
  a.method2(new Covariant<Lower>());

  B b = new B();
  Expect.type<Covariant<Upper>>(b.method1());
  Expect.type<Covariant<Middle>>(b.method1());
  Expect.type<Covariant<Lower>>(b.method1());
  b.method2(new Covariant<Upper>());
  b.method2(new Covariant<Middle>());

  C c = new C();
  Expect.type<Covariant<Middle>>(c.method1());
  Expect.type<Covariant<Upper>>(c.method1());
  Expect.notType<Covariant<Lower>>(c.method1());
  c.method2(new Covariant<Middle>());
  c.method2(new Covariant<Lower>());

  D<Covariant<Lower>> dLower = new D<Covariant<Lower>>();
  D<Covariant<Middle>> dMiddle = new D<Covariant<Middle>>();

  E e = new E();
  Expect.type<D<Covariant<Lower>>>(e.method1());
  Expect.type<D<Covariant<Middle>>>(e.method1());

  F f = new F();
  Expect.type<D<Covariant<Middle>>>(f.method1());

  Iterable<Covariant<Middle>> iterableMiddle = [new Covariant<Middle>()];
  List<Covariant<Lower>> listLower = [new Covariant<Lower>()];
  iterableMiddle = listLower;

  testCall(listLower);
  Expect.subtype<List<Covariant<Lower>>, Iterable<Covariant<Middle>>>();
  Expect.notSubtype<Iterable<Covariant<Middle>>, List<Covariant<Lower>>>();
  Expect.notSubtype<List<Covariant<Upper>>, Iterable<Covariant<Middle>>>();

  Expect.subtype<Covariant<Lower>, Covariant<Middle>>();
  Expect.subtype<Covariant<Middle>, Covariant<Middle>>();
  Expect.notSubtype<Covariant<Upper>, Covariant<Middle>>();

  Expect.subtype<Covariant<Lower> Function(String),
      Covariant<Middle> Function(String)>();
  Expect.notSubtype<Covariant<Middle> Function(String),
      Covariant<Lower> Function(String)>();
  Expect.subtype<String Function(Covariant<Upper>),
      String Function(Covariant<Middle>)>();
  Expect.notSubtype<String Function(Covariant<Middle>),
      String Function(Covariant<Upper>)>();
  Expect.notSubtype<Covariant<Upper> Function(String),
      Covariant<Middle> Function(String)>();
}