Implement subtype for type variables.

tests/compiler/dart2js/subtype_test.dart

 // Copyright (c) 2013, 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.
 
 library subtype_test;
 
 import 'type_test_helper.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart"
        show Element, ClassElement;
 
 void main() {
   testInterfaceSubtype();
+  testTypeVariableSubtype();
 }
 
 void testInterfaceSubtype() {
   var env = new TypeEnvironment(r"""
       class A<T> {}
       class B<T1,T2> extends A<T1> {}
       // TODO(johnniwinther): Inheritance with different type arguments is
       // currently not supported by the implementation.
       class C<T1,T2> extends B<T2,T1> /*implements A<A<T1>>*/ {}
       """);
@@ skipping 185 matching lines @@
 
   expect(false, C_int_String, A_int);
   expect(true, C_int_String, A_String);
   // TODO(johnniwinther): Inheritance with different type arguments is
   // currently not supported by the implementation.
   //expect(true, C_int_String, instantiate(A, [A_int]));
   expect(false, C_int_String, instantiate(A, [A_String]));
 }
 
 
+void testTypeVariableSubtype() {
+  var env = new TypeEnvironment(r"""
+      class A<T, S extends Object, U extends int> {}
+      class B<T, S extends T, U extends S> {}
+      """);
+
+  void expect(bool value, DartType T, DartType S) {
+    print('$T <: $S');
+    Expect.equals(value, env.isSubtype(T, S), '$T <: $S');
+  }
+
+  DartType Object_ = env['Object'];
+  DartType num_ = env['num'];
+  DartType int_ = env['int'];
+  DartType dynamic_ = env['dynamic'];
+
+  InterfaceType A = env['A'];
+  DartType A_T = A.typeArguments.head;
+  DartType A_S = A.typeArguments.skip(1).head;
+  DartType A_U = A.typeArguments.skip(2).head;
+
+
+  InterfaceType B = env['B'];
+  DartType B_T = B.typeArguments.head;
+  DartType B_S = B.typeArguments.skip(1).head;
+  DartType B_U = B.typeArguments.skip(2).head;
+
+  expect(true, A_T, A_T);
+  expect(false, A_T, A_S);
+  expect(false, A_T, A_U);
+  expect(false, A_T, B_T);
+  expect(false, A_T, B_S);
+  expect(false, A_T, B_U);
+  expect(true, A_T, Object_);
+  expect(false, A_T, num_);
+  expect(false, A_T, int_);
+  expect(true, A_T, dynamic_);
+
+  expect(false, A_S, A_T);
+  expect(true, A_S, A_S);
+  expect(false, A_S, A_U);
+  expect(false, A_S, B_T);
+  expect(false, A_S, B_S);
+  expect(false, A_S, B_U);
+  expect(true, A_S, Object_);
+  expect(false, A_S, num_);
+  expect(false, A_S, int_);
+  expect(true, A_S, dynamic_);
+
+  expect(false, A_U, A_T);
+  expect(false, A_U, A_S);
+  expect(true, A_U, A_U);
+  expect(false, A_U, B_T);
+  expect(false, A_U, B_S);
+  expect(false, A_U, B_U);
+  expect(true, A_U, Object_);
+  expect(true, A_U, num_);
+  expect(true, A_U, int_);
+  expect(true, A_U, dynamic_);
+
+  expect(false, B_T, A_T);
+  expect(false, B_T, A_S);
+  expect(false, B_T, A_U);
+  expect(true, B_T, B_T);
+  expect(false, B_T, B_S);
+  expect(false, B_T, B_U);
+  expect(true, B_T, Object_);
+  expect(false, B_T, num_);
+  expect(false, B_T, int_);
+  expect(true, B_T, dynamic_);
+
+  expect(false, B_S, A_T);
+  expect(false, B_S, A_S);
+  expect(false, B_S, A_U);
+  expect(true, B_S, B_T);
+  expect(true, B_S, B_S);
+  expect(false, B_S, B_U);
+  expect(true, B_S, Object_);
+  expect(false, B_S, num_);
+  expect(false, B_S, int_);
+  expect(true, B_S, dynamic_);
+
+  expect(false, B_U, A_T);
+  expect(false, B_U, A_S);
+  expect(false, B_U, A_U);
+  expect(true, B_U, B_T);
+  expect(true, B_U, B_S);
+  expect(true, B_U, B_U);
+  expect(true, B_U, Object_);
+  expect(false, B_U, num_);
+  expect(false, B_U, int_);
+  expect(true, B_U, dynamic_);
+}