Add mixin support to source mirrors.

tests/compiler/dart2js/mirrors_mixin_test.dart

Index: tests/compiler/dart2js/mirrors_mixin_test.dart
diff --git a/tests/compiler/dart2js/mirrors_mixin_test.dart b/tests/compiler/dart2js/mirrors_mixin_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..148685145025211b1416d12c754a06d98b7e7bd5
--- /dev/null
+++ b/tests/compiler/dart2js/mirrors_mixin_test.dart
@@ -0,0 +1,240 @@
+// 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 mirrors_mixin_test;
+
+import 'package:expect/expect.dart';
+import 'package:async_helper/async_helper.dart';
+import 'mirror_system_helper.dart';
+
+const String CLASS_SOURCE = '''
+class A {}
+
+class S {}
+class M1<T> {}
+class M2 {}
+
+class C extends S with M1<A> {}
+class D extends S with M1, M2 {}
+class E extends S with M2, M1 implements A, M1 {}
+class E2 extends E {}
+
+class F = S with M1<A>;
+abstract class G = S with M1, M2;
+class H = S with M2, M1 implements A, M1;
+class H2 extends H {}
+''';
+
+void main() {
+  asyncTest(() => createMirrorSystem(CLASS_SOURCE).then((MirrorSystem mirrors) {
+    LibraryMirror library = mirrors.libraries[SOURCE_URI];
+
+    checkSimpleClass(var cls) {
+      Expect.isNotNull(cls);
+      Expect.isTrue(cls is ClassMirror);
+      Expect.isFalse(isMixinApplication(cls));
+      Expect.isFalse(cls.isNameSynthetic);
+      Expect.isFalse(cls.isObject);
+      Expect.isTrue(cls.superclass.isObject);
+      Expect.equals(0, cls.superinterfaces.length);
+
+      Expect.isTrue(getSuperclass(cls).isObject);
+      Expect.isTrue(getAppliedMixins(cls).isEmpty);
+      Expect.isTrue(getExplicitInterfaces(cls).isEmpty);
+    }
+
+    // class A {}
+    var A = library.classes['A'];
+    checkSimpleClass(A);
+
+    // class S {}
+    var S = library.classes['S'];
+    checkSimpleClass(S);
+
+    // class M1 {}
+    var M1 = library.classes['M1'];
+    checkSimpleClass(M1);
+
+    // class M2 {}
+    var M2 = library.classes['M2'];
+    checkSimpleClass(M2);
+
+    // class C extends S with M1<A> {}
+    var C = library.classes['C'];
+    Expect.isNotNull(C);
+    Expect.isTrue(C is ClassMirror);
+    Expect.isFalse(isMixinApplication(C));
+    Expect.isFalse(C.isObject);
+    Expect.equals(0, C.superinterfaces.length);
+    var C_super = C.superclass;
+    Expect.isNotNull(C_super);
+    Expect.isTrue(C_super is ClassMirror);
+    Expect.isTrue(isMixinApplication(C_super));
+    Expect.isTrue(C_super.isNameSynthetic);
+    Expect.equals(1, C_super.superinterfaces.length);
+    Expect.isTrue(containsType(M1, [A], C_super.superinterfaces));
+    Expect.isTrue(isInstance(M1, [A], C_super.mixin));
+    Expect.isFalse(C_super.isObject);
+    Expect.isTrue(isSameDeclaration(S, C_super.superclass));
+
+    Expect.isTrue(isSameDeclaration(S, getSuperclass(C)));
+    Expect.isTrue(isSameDeclarationList([M1], getAppliedMixins(C)));
+    Expect.isTrue(getExplicitInterfaces(C).isEmpty);
+
+    // D extends S with M1, M2 {}
+    var D = library.classes['D'];
+    Expect.isNotNull(D);
+    Expect.isTrue(D is ClassMirror);
+    Expect.isFalse(isMixinApplication(D));
+    Expect.isFalse(D.isObject);
+    Expect.equals(0, D.superinterfaces.length);
+    var D_super = D.superclass;
+    Expect.isNotNull(D_super);
+    Expect.isTrue(D_super is ClassMirror);
+    Expect.isTrue(isMixinApplication(D_super));
+    Expect.isTrue(D_super.isNameSynthetic);
+    Expect.equals(1, D_super.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(M2, D_super.superinterfaces));
+    Expect.isTrue(isSameDeclaration(M2, D_super.mixin));
+    Expect.isFalse(D_super.isObject);
+    Expect.isFalse(isSameDeclaration(S, D_super.superclass));
+    var D_super_super = D_super.superclass;
+    Expect.isNotNull(D_super_super);
+    Expect.isTrue(D_super_super is ClassMirror);
+    Expect.isTrue(isMixinApplication(D_super_super));
+    Expect.isTrue(D_super_super.isNameSynthetic);
+    Expect.equals(1, D_super_super.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(M1, D_super_super.superinterfaces));
+    Expect.isTrue(isSameDeclaration(M1, D_super_super.mixin));
+    Expect.isFalse(D_super_super.isObject);
+    Expect.isTrue(isSameDeclaration(S, D_super_super.superclass));
+
+    Expect.isTrue(isSameDeclaration(S, getSuperclass(D)));
+    Expect.isTrue(isSameDeclarationList([M1, M2], getAppliedMixins(D)));
+    Expect.isTrue(getExplicitInterfaces(D).isEmpty);
+
+    // class E extends S with M2, M1 implements A, M1 {}
+    var E = library.classes['E'];
+    Expect.isNotNull(E);
+    Expect.isTrue(E is ClassMirror);
+    Expect.isFalse(isMixinApplication(E));
+    Expect.isFalse(E.isObject);
+    Expect.equals(2, E.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(A, E.superinterfaces));
+    Expect.isTrue(containsDeclaration(M1, E.superinterfaces));
+    var E_super = E.superclass;
+    Expect.isNotNull(E_super);
+    Expect.isTrue(E_super is ClassMirror);
+    Expect.isTrue(isMixinApplication(E_super));
+    Expect.isTrue(E_super.isNameSynthetic);
+    Expect.equals(1, E_super.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(M1, E_super.superinterfaces));
+    Expect.isTrue(isSameDeclaration(M1, E_super.mixin));
+    Expect.isFalse(E_super.isObject);
+    Expect.isFalse(isSameDeclaration(S, E_super.superclass));
+    var E_super_super = E_super.superclass;
+    Expect.isNotNull(E_super_super);
+    Expect.isTrue(E_super_super is ClassMirror);
+    Expect.isTrue(isMixinApplication(E_super_super));
+    Expect.isTrue(E_super_super.isNameSynthetic);
+    Expect.equals(1, E_super_super.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(M2, E_super_super.superinterfaces));
+    Expect.isTrue(isSameDeclaration(M2, E_super_super.mixin));
+    Expect.isFalse(E_super_super.isObject);
+    Expect.isTrue(isSameDeclaration(S, E_super_super.superclass));
+
+    Expect.isTrue(isSameDeclaration(S, getSuperclass(E)));
+    Expect.isTrue(isSameDeclarationList([M2, M1], getAppliedMixins(E)));
+    Expect.isTrue(isSameDeclarationSet([A, M1], getExplicitInterfaces(E)));
+
+    // class E2 extends E {}
+    var E2 = library.classes['E2'];
+    Expect.isTrue(isSameDeclaration(E, getSuperclass(E2)));
+    Expect.isTrue(getAppliedMixins(E2).isEmpty);
+    Expect.isTrue(getExplicitInterfaces(E2).isEmpty);
+
+    // class F = S with M1<A>;
+    var F = library.classes['F'];
+    Expect.isNotNull(F);
+    Expect.isTrue(F is ClassMirror);
+    Expect.isFalse(F.isAbstract);
+    Expect.isTrue(isMixinApplication(F));
+    Expect.isFalse(F.isNameSynthetic);
+    Expect.equals('F', F.simpleName);
+    Expect.isFalse(F.isObject);
+    Expect.equals(1, F.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(M1, F.superinterfaces));
+    Expect.isTrue(isInstance(M1, [A], F.mixin));
+    var F_super = F.superclass;
+    Expect.isNotNull(F_super);
+    Expect.isTrue(F_super is ClassMirror);
+    Expect.isFalse(isMixinApplication(F_super));
+    Expect.isFalse(F_super.isObject);
+    Expect.isTrue(isSameDeclaration(S, F_super));
+
+    Expect.isTrue(isSameDeclaration(S, getSuperclass(F)));
+    Expect.isTrue(isSameDeclarationList([M1], getAppliedMixins(F)));
+    Expect.isTrue(getExplicitInterfaces(F).isEmpty);
+
+    // typedef G = abstract S with M1, M2;
+    var G = library.classes['G'];
+    Expect.isNotNull(G);
+    Expect.isTrue(G is ClassMirror);
+    Expect.isTrue(G.isAbstract);
+    Expect.isTrue(isMixinApplication(G));
+    Expect.isFalse(G.isNameSynthetic);
+    Expect.equals('G', G.simpleName);
+    Expect.isFalse(G.isObject);
+    Expect.equals(1, G.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(M2, G.superinterfaces));
+    Expect.isTrue(isSameDeclaration(M2, G.mixin));
+    var G_super = G.superclass;
+    Expect.isNotNull(G_super);
+    Expect.isTrue(G_super is ClassMirror);
+    Expect.isTrue(isMixinApplication(G_super));
+    Expect.equals(1, G_super.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(M1, G_super.superinterfaces));
+    Expect.isTrue(isSameDeclaration(M1, G_super.mixin));
+    Expect.isFalse(G_super.isObject);
+    Expect.isTrue(isSameDeclaration(S, G_super.superclass));
+
+    Expect.isTrue(isSameDeclaration(S, getSuperclass(G)));
+    Expect.isTrue(isSameDeclarationList([M1, M2], getAppliedMixins(G)));
+    Expect.isTrue(getExplicitInterfaces(G).isEmpty);
+
+    // typedef H = S with M2, M1 implements A, M1;
+    var H = library.classes['H'];
+    Expect.isNotNull(H);
+    Expect.isTrue(H is ClassMirror);
+    Expect.isFalse(H.isAbstract);
+    Expect.isTrue(isMixinApplication(H));
+    Expect.isFalse(H.isNameSynthetic);
+    Expect.equals('H', H.simpleName);
+    Expect.isFalse(H.isObject);
+    Expect.equals(3, H.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(A, H.superinterfaces));
+    Expect.isTrue(containsDeclaration(M1, H.superinterfaces));
+    Expect.isFalse(containsDeclaration(M2, H.superinterfaces));
+    Expect.isTrue(isSameDeclaration(M1, H.mixin));
+    var H_super = H.superclass;
+    Expect.isNotNull(H_super);
+    Expect.isTrue(H_super is ClassMirror);
+    Expect.isTrue(isMixinApplication(H_super));
+    Expect.equals(1, H_super.superinterfaces.length);
+    Expect.isTrue(containsDeclaration(M2, H_super.superinterfaces));
+    Expect.isTrue(isSameDeclaration(M2, H_super.mixin));
+    Expect.isFalse(H_super.isObject);
+    Expect.isTrue(isSameDeclaration(S, H_super.superclass));
+
+    Expect.isTrue(isSameDeclaration(S, getSuperclass(H)));
+    Expect.isTrue(isSameDeclarationList([M2, M1], getAppliedMixins(H)));
+    Expect.isTrue(isSameDeclarationSet([A, M1], getExplicitInterfaces(H)));
+
+    // class H2 extends H {}
+    var H2 = library.classes['H2'];
+    Expect.isTrue(isSameDeclaration(H, getSuperclass(H2)));
+    Expect.isTrue(getAppliedMixins(H2).isEmpty);
+    Expect.isTrue(getExplicitInterfaces(H2).isEmpty);
+  }));
+}