Add mixin support to source mirrors.

tests/compiler/dart2js/mirror_system_helper.dart

Index: tests/compiler/dart2js/mirror_system_helper.dart
diff --git a/tests/compiler/dart2js/mirror_system_helper.dart b/tests/compiler/dart2js/mirror_system_helper.dart
new file mode 100644
index 0000000000000000000000000000000000000000..2776de664d2047971a71b2213b95afb8a8273c88
--- /dev/null
+++ b/tests/compiler/dart2js/mirror_system_helper.dart
@@ -0,0 +1,139 @@
+// 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 mirror_system_helper;
+
+import 'dart:async';
+import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
+import '../../../sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart';
+import 'mock_compiler.dart';
+
+export '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
+export '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart';
+
+const String SOURCE = 'source';
+final Uri SOURCE_URI = new Uri(scheme: SOURCE, path: SOURCE);
+
+// TODO(johnniwinther): Move this to a mirrors helper library.
+Future<MirrorSystem> createMirrorSystem(String source) {
+  MockCompiler compiler = new MockCompiler(
+      analyzeOnly: true,
+      analyzeAll: true,
+      preserveComments: true);
+    compiler.registerSource(SOURCE_URI, source);
+    compiler.librariesToAnalyzeWhenRun = <Uri>[SOURCE_URI];
+  return compiler.runCompiler(null).then((_) {
+    return new Dart2JsMirrorSystem(compiler);
+  });
+}
+
+/**
+ * Returns [:true:] if [type] is an instance of [:decl:] with type arguments
+ * equal to [typeArgument].
+ */
+bool isInstance(ClassMirror decl, List<TypeMirror> typeArguments,
+            ClassMirror type) {
+  if (type.isOriginalDeclaration) return false;
+  if (!isSameDeclaration(decl, type)) return false;
+  return areEqualsTypes(typeArguments, type.typeArguments);
+}
+
+/**
+ * Returns [:true:] if [type] is the same type as [expected]. This method
+ * equates a non-generic declaration with its instantiation.
+ */
+bool isEqualType(TypeMirror expected, TypeMirror type) {
+  if (expected == type) return true;
+  if (expected is ClassMirror && type is ClassMirror) {
+    if (!isSameDeclaration(expected, type)) return false;
+    if (expected.isOriginalDeclaration || expected.typeArguments.isEmpty) {
+      return type.isOriginalDeclaration || type.typeArguments.isEmpty;
+    }
+    return areEqualsTypes(expected.typeArguments, type.typeArguments);
+  }
+  return true;
+}
+
+/**
+ * Returns [:true:] if [types] are equals to [expected] using the equalitry
+ * defined by [isEqualType].
+ */
+bool areEqualsTypes(List<TypeMirror> expected, List<TypeMirror> types) {
+  return checkSameList(expected, types, isEqualType);
+}
+
+/**
+ * Returns [:true:] if an instance of [type] with type arguments equal to
+ * [typeArguments] is found in [types].
+ */
+bool containsType(ClassMirror decl, List<TypeMirror> typeArguments,
+                  Iterable<TypeMirror> types) {
+  return types.any((type) => isInstance(decl, typeArguments, type));
+}
+
+/**
+ * Returns the declaration of [type].
+ */
+TypeMirror toDeclaration(TypeMirror type) {
+  return type is ClassMirror ? type.originalDeclaration : type;
+}
+
+/**
+ * Returns [:true:] if [type] is of the same declaration as [expected].
+ */
+bool isSameDeclaration(TypeMirror expected, TypeMirror type) {
+  return toDeclaration(expected) == toDeclaration(type);
+}
+
+/**
+ * Returns [:true:] if a type of the declaration of [expected] is in [types].
+ */
+bool containsDeclaration(TypeMirror expected, Iterable<TypeMirror> types) {
+  for (var type in types) {
+    if (isSameDeclaration(expected, type)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Returns [:true:] if declarations of [expected] are the same as those of
+ * [types], taking order into account.
+ */
+bool isSameDeclarationList(Iterable<TypeMirror> expected,
+                           Iterable<TypeMirror> types) {
+  return checkSameList(expected, types, isSameDeclaration);
+}
+
+/**
+ * Returns [:true:] if declarations of [expected] are the same as those of
+ * [iterable], not taking order into account.
+ */
+bool isSameDeclarationSet(Iterable<TypeMirror> expected,
+                          Iterable<TypeMirror> types) {
+   Set<TypeMirror> expectedSet = expected.map(toDeclaration).toSet();
+   Set<TypeMirror> typesSet = types.map(toDeclaration).toSet();
+   return expectedSet.length == typesSet.length &&
+          expectedSet.containsAll(typesSet);
+}
+
+/**
+ * Utility method for checking whether [expected] and [iterable] contains the
+ * same elements with respect to the checking function [check], takin order
+ * into account.
+ */
+bool checkSameList(Iterable<TypeMirror> expected,
+                   Iterable<TypeMirror> types,
+                   bool check(TypeMirror a, TypeMirror b)) {
+  if (expected.length != types.length) return false;
+  Iterator<TypeMirror> expectedIterator = expected.iterator;
+  Iterator<TypeMirror> typesIterator = types.iterator;
+  while (expectedIterator.moveNext() && typesIterator.moveNext()) {
+    if (!check(expectedIterator.current, typesIterator.current)) {
+      return false;
+    }
+  }
+  return true;
+}