Add order to DartType.

tests/compiler/dart2js/type_order_test.dart

Index: tests/compiler/dart2js/type_order_test.dart
diff --git a/tests/compiler/dart2js/type_order_test.dart b/tests/compiler/dart2js/type_order_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..eb6a7c5a303cd0657f359abacf2bf951e2c7f65e
--- /dev/null
+++ b/tests/compiler/dart2js/type_order_test.dart
@@ -0,0 +1,72 @@
+// 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 'package:expect/expect.dart';
+import 'package:async_helper/async_helper.dart';
+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, TypedefElement;
+
+void main() {
+  asyncTest(() => TypeEnvironment.create(r"""
+      class A<AT, AS> {}
+      typedef BS B<BT, BS>(BT t);
+      class C<CT, CS> extends A<CS, CT> {}
+      class X {}
+      class Y {}
+      class Z {}
+      """).then((env) {
+
+    List types = [];
+    DartType add(DartType type) {
+      types.add(type);
+      return type;
+    }
+
+    DartType dynamic_ = add(env['dynamic']);
+    DartType void_ = add(env['void']);
+
+    ClassElement A = env.getElement('A');
+    TypedefElement B = env.getElement('B');
+    ClassElement C = env.getElement('C');
+    DartType X = add(env['X']);
+    DartType Y = add(env['Y']);
+    DartType Z = add(env['Z']);
+
+    InterfaceType A_this = add(A.thisType);
+    InterfaceType A_raw = add(A.rawType);
+    TypeVariableType AT = add(A_this.typeArguments.head);
+    TypeVariableType AS = add(A_this.typeArguments.tail.head);
+    InterfaceType A_X_Y = add(instantiate(A, [X, Y]));
+    InterfaceType A_Y_X = add(instantiate(A, [Y, X]));
+
+    TypedefType B_this = add(B.computeType(env.compiler));
+    TypedefType B_raw = add(B.rawType);
+    TypeVariableType BT = add(B_this.typeArguments.head);
+    TypeVariableType BS = add(B_this.typeArguments.tail.head);
+    FunctionType B_this_alias = add(B.alias);
+    TypedefType B_X_Y = add(instantiate(B, [X, Y]));
+    FunctionType B_X_Y_alias = add(B_X_Y.unalias(env.compiler));
+    TypedefType B_Y_X = add(instantiate(B, [Y, X]));
+    FunctionType B_Y_X_alias = add(B_Y_X.unalias(env.compiler));
+
+    InterfaceType C_this = add(C.thisType);
+    InterfaceType C_raw = add(C.rawType);
+    TypeVariableType CT = add(C_this.typeArguments.head);
+    TypeVariableType CS = add(C_this.typeArguments.tail.head);
+
+    Expect.listEquals(
+        [void_, dynamic_,
+         A_raw, A_this, A_X_Y, A_Y_X, AT, AS,
+         B_raw, B_this, B_X_Y, B_Y_X, BT, BS,
+         C_raw, C_this, CT, CS,
+         X, Y, Z,
+         B_this_alias, B_Y_X_alias, B_X_Y_alias,
+        ],
+        Types.sorted(types));
+  }));
+}