Language/Types/Function_Types/subtype_required_args_t02.dart

// Copyright (c) 2011, 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 A function type (T1,...Tk,[Tk+1,...,Tn+m]) -> T is a subtype of
/// the function type (S1,...,Sk+j,[Sk+j+1,...,Sn]) -> S, if all of the following
/// conditions are met:
/// 1. Either
///    • S is void, or
///    • T <=> S.
/// 2. ∀i ∈ 1..n, Ti ⇐⇒ Si.
/// @description Checks that this statement is true for function types with
/// several formal parameters (class, generic, function, Dynamic).
/// @author iefremov

import "../../../Utils/expect.dart";

class A {}
class A1 {}
class A2 {}
class B implements A, A1, A2 {}
class C implements B {}
class D implements C {}

class G<T, S, U, W> {}

typedef classesFunc(A a, B b, C c, D d);
typedef genericsFunc(Map<num, int> m, List<List<B>> l, G<A, B, C, D> g);
typedef dynamicFunc(var x, var y, var z, var v);
typedef funcFunc(classesFunc f1, genericsFunc f2, dynamicFunc f3);
typedef mixFunc(var x, B b, G<A, B, C, D> g, funcFunc);

typedef okWithClassesFunc_1(A a, A1 b, A1 c, A1 d);
typedef okWithClassesFunc_2(D a, D b, D c, D d);

typedef okWithGenericsFunc_1(Map<num, num> m, List<List<A1>> l, G<A, A1, A1, A1> g);
typedef okWithGenericsFunc_2(Map<int, int> m, List<List<D>> l, G<D, D, D, D> g);

typedef okWithDynamicFunc_1(A x, G g, mixFunc f, var z);
typedef okWithDynamicFunc_2(int x, bool g, List<Map> f, classesFunc z);

f1(D d, B b, C c, A a) {}
f2(A d, A b, A c, A a) {}
f3(D d, A1 b, A1 c, A1 a) {}
f4(D d, A2 b, A2 c, A2 a) {}
f5(D d, D b, D c, D a) {}
f6(var d, var b, var c, var a) {}
f7(Object d, Object b, Object c, Object a) {}

f11(Map<num, num> m, List<List<A1>> l, G<A, A1, A1, A1> g) {}
f12(Map<int, int> m, List<List<D>> l, G<D, D, D, D> g) {}
f13(var m, var l, var g) {}
f14(Object m, Object l, Object g) {}

f21(A x, G g, mixFunc d, var z) {}
f22(int x, bool g, List<Map> d, classesFunc z) {}

f31(okWithClassesFunc_1 a, okWithGenericsFunc_1 b, okWithDynamicFunc_1 c) {}
f32(okWithClassesFunc_2 a, okWithGenericsFunc_2 b, okWithDynamicFunc_2 c) {}

main() {
  Expect.isFalse(f1 is classesFunc);
  Expect.isTrue(f2 is classesFunc);
  Expect.isFalse(f3 is classesFunc);
  Expect.isFalse(f4 is classesFunc);
  Expect.isFalse(f5 is classesFunc);
  Expect.isTrue(f6 is classesFunc);
  Expect.isTrue(f7 is classesFunc);
  Expect.runtimeIsNotType<classesFunc>(f1);
  Expect.runtimeIsType<classesFunc>(f2);
  Expect.runtimeIsNotType<classesFunc>(f3);
  Expect.runtimeIsNotType<classesFunc>(f4);
  Expect.runtimeIsNotType<classesFunc>(f5);
  Expect.runtimeIsType<classesFunc>(f6);
  Expect.runtimeIsType<classesFunc>(f7);

  Expect.isTrue(f11 is genericsFunc);
  Expect.isFalse(f12 is genericsFunc);
  Expect.isTrue(f13 is genericsFunc);
  Expect.isTrue(f14 is genericsFunc);
  Expect.runtimeIsType<genericsFunc>(f11);
  Expect.runtimeIsNotType<genericsFunc>(f12);
  Expect.runtimeIsType<genericsFunc>(f13);
  Expect.runtimeIsType<genericsFunc>(f14);

  Expect.isFalse(f21 is dynamicFunc);
  Expect.isFalse(f22 is dynamicFunc);
  Expect.runtimeIsNotType<dynamicFunc>(f21);
  Expect.runtimeIsNotType<dynamicFunc>(f22);

  Expect.isFalse(f31 is funcFunc);
  Expect.isTrue(f32 is funcFunc);
  Expect.runtimeIsNotType<funcFunc>(f31);
  Expect.runtimeIsType<funcFunc>(f32);
}