Check variance of type-parameter use in supertypes.

Tests have both correct and erroneous implementations
of variance.

Change-Id: I49dd76f42399015dd6e3f9688e598c271ce7ab1c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/119722
Commit-Queue: Kallen Tu <kallentu@google.com>
Reviewed-by: Leaf Petersen <leafp@google.com>
Reviewed-by: Dmitry Stefantsov <dmitryas@google.com>

Author: kallentu

pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart

@@ -5,7 +5,7 @@
 library fasta.type_variable_builder;
 
 import 'package:kernel/ast.dart'
-    show DartType, Nullability, TypeParameter, TypeParameterType;
+    show DartType, Nullability, TypeParameter, TypeParameterType, Variance;
 
 import '../fasta_codes.dart'
     show
@@ -38,9 +38,12 @@ class TypeVariableBuilder extends TypeDeclarationBuilderImpl {
 
   TypeVariableBuilder(
       String name, SourceLibraryBuilder compilationUnit, int charOffset,
-      {this.bound, this.isExtensionTypeParameter: false})
+      {this.bound,
+      this.isExtensionTypeParameter: false,
+      int variableVariance: Variance.covariant})
       : actualParameter = new TypeParameter(name, null)
-          ..fileOffset = charOffset,
+          ..fileOffset = charOffset
+          ..variance = variableVariance,
         super(null, 0, name, compilationUnit, charOffset);
 
   TypeVariableBuilder.fromKernel(
@@ -235,7 +238,7 @@ class TypeVariableBuilder extends TypeDeclarationBuilderImpl {
     // An alternative is to use the offset of the node the cloned type variable
     // is declared on.
     return new TypeVariableBuilder(name, parent, charOffset,
-        bound: bound.clone(newTypes));
+        bound: bound.clone(newTypes), variableVariance: variance);
   }
 
   @override

pkg/front_end/lib/src/fasta/kernel/type_algorithms.dart

@@ -66,8 +66,11 @@ int computeVariance(TypeVariableBuilder variable, TypeBuilder type) {
       if (declaration is ClassBuilder) {
         int result = Variance.unrelated;
         if (type.arguments != null) {
-          for (TypeBuilder argument in type.arguments) {
-            result = Variance.meet(result, computeVariance(variable, argument));
+          for (int i = 0; i < type.arguments.length; ++i) {
+            result = Variance.meet(
+                result,
+                Variance.combine(declaration.cls.typeParameters[i].variance,
+                    computeVariance(variable, type.arguments[i])));
           }
         }
         return result;

pkg/front_end/lib/src/fasta/source/source_class_builder.dart

@@ -239,8 +239,7 @@ class SourceClassBuilder extends ClassBuilderImpl
     Message message;
     for (int i = 0; i < typeVariables.length; ++i) {
       int variance = computeVariance(typeVariables[i], supertype);
-      if (variance == Variance.contravariant ||
-          variance == Variance.invariant) {
+      if (!Variance.greaterThanOrEqual(variance, typeVariables[i].variance)) {
         message = templateBadTypeVariableInSupertype.withArguments(
             typeVariables[i].name, supertype.name);
         library.addProblem(message, charOffset, noLength, fileUri);

pkg/front_end/lib/src/fasta/source/source_library_builder.dart

@@ -2334,7 +2334,8 @@ class SourceLibraryBuilder extends LibraryBuilderImpl {
       TypeVariableBuilder newVariable = new TypeVariableBuilder(
           variable.name, this, variable.charOffset,
           bound: variable.bound?.clone(newTypes),
-          isExtensionTypeParameter: isExtensionTypeParameter);
+          isExtensionTypeParameter: isExtensionTypeParameter,
+          variableVariance: variable.variance);
       copy.add(newVariable);
       boundlessTypeVariables.add(newVariable);
     }

pkg/front_end/test/spell_checking_list_common.txt

@@ -1326,6 +1326,7 @@ indices
 indirect
 indirectly
 induce
+induced
 infer
 inference
 inferrable

pkg/kernel/lib/ast.dart

@@ -6045,6 +6045,30 @@ class Variance {
     return a == b ? covariant : contravariant;
   }
 
+  /// Returns true if [a] is greater than (above) [b] in the partial order
+  /// induced by the variance lattice.
+  static bool greaterThan(int a, int b) {
+    return greaterThanOrEqual(a, b) && a != b;
+  }
+
+  /// Returns true if [a] is greater than (above) or equal to [b] in the
+  /// partial order induced by the variance lattice.
+  static bool greaterThanOrEqual(int a, int b) {
+    return meet(a, b) == b;
+  }
+
+  /// Returns true if [a] is less than (below) [b] in the partial order
+  /// induced by the variance lattice.
+  static bool lessThan(int a, int b) {
+    return lessThanOrEqual(a, b) && a != b;
+  }
+
+  /// Returns true if [a] is less than (below) or equal to [b] in the
+  /// partial order induced by the variance lattice.
+  static bool lessThanOrEqual(int a, int b) {
+    return meet(a, b) == a;
+  }
+
   static int fromString(String variance) {
     if (variance == "in") {
       return contravariant;

tests/language_2/variance/variance_in_subclass_error_test.dart

@@ -0,0 +1,123 @@
+// 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 erroneous subclass usage for the `in` variance modifier.
+
+// SharedOptions=--enable-experiment=variance
+
+typedef CovFunction<T> = T Function();
+typedef ContraFunction<T> = void Function(T);
+typedef InvFunction<T> = T Function(T);
+
+class LegacyCovariant<T> {}
+class Covariant<out T> {}
+class Contravariant<in T> {}
+class Invariant<inout T> {}
+mixin MLegacyCovariant<T> {}
+mixin MCovariant<out T> {}
+mixin MContravariant<in T> {}
+mixin MInvariant<inout T> {}
+
+class A<in T> extends LegacyCovariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'LegacyCovariant'.
+
+class B<in T> implements LegacyCovariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'LegacyCovariant'.
+
+class C<in T> with MLegacyCovariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'MLegacyCovariant'.
+
+class D<in T> extends Covariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Covariant'.
+
+class E<in T> implements Covariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Covariant'.
+
+class F<in T> with MCovariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'MCovariant'.
+
+class G<in T> extends Invariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Invariant'.
+
+class H<in T> implements Invariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Invariant'.
+
+class I<in T> with MInvariant<T> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'MInvariant'.
+
+class J<in T> extends Covariant<Covariant<T>> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Covariant'.
+
+class K<in T> extends Contravariant<Contravariant<T>> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Contravariant'.
+
+class L<in T> extends Covariant<CovFunction<T>> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Covariant'.
+
+class M<in T> extends Covariant<ContraFunction<ContraFunction<T>>> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Covariant'.
+
+class N<in T> extends Contravariant<CovFunction<Contravariant<T>>> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Contravariant'.
+
+class O<in T> extends Covariant<CovFunction<Covariant<T>>> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Covariant'.
+
+class P<in T> extends Covariant<Covariant<Covariant<T>>> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Covariant'.
+
+class Q<in T> extends Invariant<InvFunction<T>> {}
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Invariant'.
+
+class R<in T> = Covariant<T> with MContravariant<T>;
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'Covariant'.
+
+class S<in T> = Contravariant<T> with MCovariant<T>;
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'T' in supertype 'MCovariant'.
+
+class T<in X> = Invariant<X> with MInvariant<X>;
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'X' in supertype 'Invariant'.
+//    ^
+// [analyzer] unspecified
+// [cfe] Found unsupported uses of 'X' in supertype 'MInvariant'.

tests/language_2/variance/variance_in_subclass_test.dart

@@ -0,0 +1,49 @@
+// 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 subclass usage for the `in` variance modifier.
+
+// SharedOptions=--enable-experiment=variance
+
+typedef CovFunction<T> = T Function();
+typedef ContraFunction<T> = void Function(T);
+
+class Covariant<out T> {}
+class Contravariant<in T> {}
+mixin MContravariant<in T> {}
+
+class A<in T> extends Contravariant<T> {}
+class B<in T> implements Contravariant<T> {}
+class C<in T> with MContravariant<T> {}
+
+class D<in T> extends Covariant<Contravariant<T>> {}
+class E<in T> extends Contravariant<Covariant<T>> {}
+
+class F<in T> extends Covariant<ContraFunction<T>> {}
+class G<in T> extends Covariant<ContraFunction<CovFunction<T>>> {}
+class H<in T> extends Covariant<CovFunction<ContraFunction<T>>> {}
+
+class I<in T> extends Covariant<ContraFunction<Covariant<T>>> {}
+
+class J<in T> extends Contravariant<Contravariant<Contravariant<T>>> {}
+
+class K<in T> = Contravariant<T> with MContravariant<T>;
+class L<in T> = Covariant<Contravariant<T>> with MContravariant<T>;
+class M<in T> = Contravariant<T> with MContravariant<Covariant<T>>;
+
+main() {
+  A<num> a = A();
+  B<num> b = B();
+  C<num> c = C();
+  D<num> d = D();
+  E<num> e = E();
+  F<num> f = F();
+  G<num> g = G();
+  H<num> h = H();
+  I<num> i = I();
+  J<num> j = J();
+  K<num> k = K();
+  L<num> l = L();
+  M<num> m = M();
+}

tests/language_2/variance/variance_inout_subclass_test.dart

@@ -0,0 +1,90 @@
+// 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 subclass usage for the `inout` variance modifier.
+
+// SharedOptions=--enable-experiment=variance
+
+typedef CovFunction<T> = T Function();
+typedef ContraFunction<T> = void Function(T);
+typedef InvFunction<T> = T Function(T);
+
+class LegacyCovariant<T> {}
+class Invariant<inout T>{}
+class Covariant<out T> {}
+class Contravariant<in T> {}
+mixin MLegacyCovariant<T> {}
+mixin MContravariant<in T> {}
+mixin MCovariant<out T> {}
+mixin MInvariant<inout T> {}
+
+class A<inout T> extends LegacyCovariant<T> {}
+class B<inout T> extends Invariant<T> {}
+class C<inout T> extends Covariant<T> {}
+class D<inout T> extends Contravariant<T> {}
+
+class E<inout T> implements LegacyCovariant<T> {}
+class F<inout T> implements Invariant<T> {}
+class G<inout T> implements Covariant<T> {}
+class H<inout T> implements Contravariant<T> {}
+
+class I<inout T> with MLegacyCovariant<T> {}
+class J<inout T> with MInvariant<T> {}
+class K<inout T> with MCovariant<T> {}
+class L<inout T> with MContravariant<T> {}
+
+class M<inout T> extends Covariant<Contravariant<T>> {}
+class N<inout T> extends Contravariant<Covariant<T>> {}
+class O<inout T> extends Covariant<ContraFunction<T>> {}
+class P<inout T> extends Covariant<ContraFunction<CovFunction<T>>> {}
+class Q<inout T> extends Covariant<CovFunction<ContraFunction<T>>> {}
+class R<inout T> extends Covariant<ContraFunction<Covariant<T>>> {}
+class S<inout T> extends Contravariant<Contravariant<Contravariant<T>>> {}
+
+class T<inout X> extends Covariant<Covariant<X>> {}
+class U<inout T> extends Contravariant<Contravariant<T>> {}
+class V<inout T> extends Covariant<CovFunction<T>> {}
+class W<inout T> extends Covariant<ContraFunction<ContraFunction<T>>> {}
+class X<inout T> extends Contravariant<CovFunction<Contravariant<T>>> {}
+class Y<inout T> extends Covariant<CovFunction<Covariant<T>>> {}
+class Z<inout T> extends Covariant<Covariant<Covariant<T>>> {}
+
+class AA<inout T> extends Covariant<InvFunction<T>> {}
+
+class AB<inout T> = Invariant<T> with MInvariant<T>;
+class AC<inout T> = Covariant<T> with MCovariant<T>;
+class AD<inout T> = Contravariant<T> with MContravariant<T>;
+
+main() {
+  A<num> a = A();
+  B<num> b = B();
+  C<num> c = C();
+  D<num> d = D();
+  E<num> e = E();
+  F<num> f = F();
+  G<num> g = G();
+  H<num> h = H();
+  I<num> i = I();
+  J<num> j = J();
+  K<num> k = K();
+  L<num> l = L();
+  M<num> m = M();
+  N<num> n = N();
+  O<num> o = O();
+  P<num> p = P();
+  Q<num> q = Q();
+  R<num> r = R();
+  S<num> s = S();
+  T<num> t = T();
+  U<num> u = U();
+  V<num> v = V();
+  W<num> w = W();
+  X<num> x = X();
+  Y<num> y = Y();
+  Z<num> z = Z();
+  AA<num> aa = AA();
+  AB<num> ab = AB();
+  AC<num> ac = AC();
+  AD<num> ad = AD();
+}