Language tests for variance modifiers.

These test basic correct usages of variance modifiers in fields
and methods.

Erroneous usages will come in a future CL, as well as more complex
examples + subclassing.


Change-Id: I05d547ac1db9e22235a0bf64b05fcb3e119e3157
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/119169
Commit-Queue: Kallen Tu <kallentu@google.com>
Reviewed-by: Leaf Petersen <leafp@google.com>
Reviewed-by: Erik Ernst <eernst@google.com>

Author: kallentu

tests/language_2/variance/variance_in_field_test.dart

@@ -0,0 +1,56 @@
+// 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 various fields for the `in` variance modifier.
+
+// SharedOptions=--enable-experiment=variance
+
+import "package:expect/expect.dart";
+
+typedef Int2Void = void Function(int);
+
+class A<in T> {
+  void set a(T value) => value;
+  final void Function(T) b = (T val) {
+    Expect.equals(2, val);
+  };
+  A<T> get c => this;
+}
+
+mixin BMixin<in T> {
+  void set a(T value) => value;
+  final void Function(T) b = (T val) {
+    Expect.equals(2, val);
+  };
+  BMixin<T> get c => this;
+}
+
+class B with BMixin<int> {}
+
+void testClass() {
+  A<int> a = new A();
+
+  a.a = 2;
+
+  Expect.type<Int2Void>(a.b);
+  a.b(2);
+
+  a.c.a = 2;
+}
+
+void testMixin() {
+  B b = new B();
+
+  b.a = 2;
+
+  Expect.type<Int2Void>(b.b);
+  b.b(2);
+
+  b.c.a = 2;
+}
+
+main() {
+  testClass();
+  testMixin();
+}

tests/language_2/variance/variance_in_method_test.dart

@@ -0,0 +1,141 @@
+// 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 method signatures and return types for the `in` variance modifier.
+
+// SharedOptions=--enable-experiment=variance
+
+import "package:expect/expect.dart";
+
+typedef Cov<T> = T Function();
+typedef Contra<T> = void Function(T);
+
+class A<in T> {
+  void method1(T x) {}
+  void method2(Cov<T> x) {}
+  Contra<T> method3() {
+    return (T val) {
+      Expect.equals(2, val);
+    };
+  }
+
+  void method4(Cov<Cov<T>> x) {}
+  Contra<Cov<T>> method5() {
+    return (Cov<T> method) {
+      Expect.type<Cov<T>>(method);
+    };
+  }
+  Cov<Contra<T>> method6() {
+    return () {
+      return (T x) {
+        Expect.equals(2, x);
+      };
+    };
+  }
+  void method7(Contra<Contra<T>> x) {}
+}
+
+mixin BMixin<in T> {
+  void method1(T x) {}
+  void method2(Cov<T> x) {}
+  Contra<T> method3() {
+    return (T val) {
+      Expect.equals(2, val);
+    };
+  }
+
+  void method4(Cov<Cov<T>> x) {}
+  Contra<Cov<T>> method5() {
+    return (Cov<T> method) {
+      Expect.type<Cov<T>>(method);
+    };
+  }
+  Cov<Contra<T>> method6() {
+    return () {
+      return (T x) {
+        Expect.equals(2, x);
+      };
+    };
+  }
+  void method7(Contra<Contra<T>> x) {}
+}
+
+class B with BMixin<int> {}
+
+class C<in T> {
+  void method1(Contra<A<T>> x) {}
+  A<T> method2() {
+    return A<T>();
+  }
+}
+
+void testClass() {
+  A<int> a = new A();
+
+  a.method1(2);
+
+  a.method2(() => 2);
+
+  Expect.type<Contra<int>>(a.method3());
+  Contra<int> method3Function = a.method3();
+  method3Function(2);
+
+  a.method4(() {
+    return () => 2;
+  });
+
+  Expect.type<Contra<Cov<int>>>(a.method5());
+  Contra<Cov<int>> method5Function = a.method5();
+  method5Function(() => 2);
+
+  Expect.type<Cov<Contra<int>>>(a.method6());
+  Cov<Contra<int>> method6Function = a.method6();
+  Expect.type<Contra<int>>(method6Function());
+  Contra<int> method6NestedFunction = method6Function();
+  method6NestedFunction(2);
+
+  a.method7((Contra<int> x) {});
+}
+
+void testMixin() {
+  B b = new B();
+
+  b.method1(2);
+
+  b.method2(() => 2);
+
+  Expect.type<Contra<int>>(b.method3());
+  Contra<int> method3Return = b.method3();
+  method3Return(2);
+
+  b.method4(() {
+    return () => 2;
+  });
+
+  Expect.type<Contra<Cov<int>>>(b.method5());
+  Contra<Cov<int>> method5Return = b.method5();
+  method5Return(() => 2);
+
+  Expect.type<Cov<Contra<int>>>(b.method6());
+  Cov<Contra<int>> method6Function = b.method6();
+  Expect.type<Contra<int>>(method6Function());
+  Contra<int> method6NestedFunction = method6Function();
+  method6NestedFunction(2);
+
+  b.method7((Contra<int> x) {});
+}
+
+void testClassInMethods() {
+  C<int> c = new C();
+
+  c.method1((A<int> x) {});
+
+  Expect.type<A<int>>(c.method2());
+}
+
+main() {
+  testClass();
+  testMixin();
+  testClassInMethods();
+}

tests/language_2/variance/variance_inout_field_test.dart

@@ -0,0 +1,73 @@
+// 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 various fields for the `inout` variance modifier.
+
+// SharedOptions=--enable-experiment=variance
+
+import "package:expect/expect.dart";
+
+typedef Void2Int = int Function();
+typedef Int2Void = void Function(int);
+
+class A<inout T> {
+  T a;
+  final T b = null;
+  final T Function() c = () => null;
+  final void Function(T) d = (T val) {
+    Expect.equals(2, val);
+  };
+  A<T> get e => this;
+}
+
+mixin BMixin<inout T> {
+  T a;
+  final T b = null;
+  final T Function() c = () => null;
+  final void Function(T) d = (T val) {
+    Expect.equals(2, val);
+  };
+  BMixin<T> get e => this;
+}
+
+class B with BMixin<int> {}
+
+void testClass() {
+  A<int> a = new A();
+
+  a.a = 2;
+  Expect.equals(2, a.a);
+
+  Expect.isNull(a.b);
+
+  Expect.type<Void2Int>(a.c);
+  Expect.isNull(a.c());
+
+  Expect.type<Int2Void>(a.d);
+  a.d(2);
+
+  a.e.a = 3;
+}
+
+void testMixin() {
+  B b = new B();
+
+  b.a = 2;
+  Expect.equals(2, b.a);
+
+  Expect.isNull(b.b);
+
+  Expect.type<Void2Int>(b.c);
+  Expect.isNull(b.c());
+
+  Expect.type<Int2Void>(b.d);
+  b.d(2);
+
+  b.e.a = 3;
+}
+
+main() {
+  testClass();
+  testMixin();
+}