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..954e907c2f1917d337b865e2018ac9fd5cbdc312
--- /dev/null
+++ b/tests/compiler/dart2js/mirrors_mixin_test.dart
@@ -0,0 +1,262 @@
+// 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 {}
+
+typedef F = S with M1<A>;
+typedef G = abstract S with M1, M2;
+typedef 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];
+
+    // class A {}
+    var A = library.classes['A'];
+    Expect.isNotNull(A);

[karlklose, 2013/11/05 10:34:18]

You could write test methods that takes the expectations for all these tests as
named arguments to share the code for the tests.

[Johnni Winther, 2013/11/05 11:20:47]

Done.

+    Expect.isTrue(A is ClassMirror);
+    Expect.isFalse(isMixinApplication(A));
+    Expect.isFalse(A.isObject);
+    Expect.isTrue(A.superclass.isObject);
+    Expect.equals(0, A.superinterfaces.length);
+
+    Expect.isTrue(getExtends(A).isObject);
+    Expect.isTrue(getWith(A).isEmpty);
+    Expect.isTrue(getImplements(A).isEmpty);
+
+    // class S {}
+    var S = library.classes['S'];
+    Expect.isNotNull(S);
+    Expect.isTrue(S is ClassMirror);
+    Expect.isFalse(isMixinApplication(S));
+    Expect.isFalse(S.isObject);
+    Expect.isTrue(S.superclass.isObject);
+    Expect.equals(0, S.superinterfaces.length);
+
+    Expect.isTrue(getExtends(S).isObject);
+    Expect.isTrue(getWith(S).isEmpty);
+    Expect.isTrue(getImplements(S).isEmpty);
+
+    // class M1 {}
+    var M1 = library.classes['M1'];
+    Expect.isNotNull(M1);
+    Expect.isTrue(M1 is ClassMirror);
+    Expect.isFalse(isMixinApplication(M1));
+    Expect.isFalse(M1.isObject);
+    Expect.isTrue(M1.superclass.isObject);
+    Expect.equals(0, M1.superinterfaces.length);
+
+    Expect.isTrue(getExtends(M1).isObject);
+    Expect.isTrue(getWith(M1).isEmpty);
+    Expect.isTrue(getImplements(M1).isEmpty);
+
+    // class M2 {}
+    var M2 = library.classes['M2'];
+    Expect.isNotNull(M2);
+    Expect.isTrue(M2 is ClassMirror);
+    Expect.isFalse(isMixinApplication(M2));
+    Expect.isFalse(M2.isObject);
+    Expect.isTrue(M2.superclass.isObject);
+    Expect.equals(0, M2.superinterfaces.length);
+
+    Expect.isTrue(getExtends(M2).isObject);
+    Expect.isTrue(getWith(M2).isEmpty);
+    Expect.isTrue(getImplements(M2).isEmpty);
+
+    // 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.isFalse(!C_super.isNameSynthetic);

[karlklose, 2013/11/05 10:34:18]

Why this double negation?

[Johnni Winther, 2013/11/05 11:20:47]

An artifact of code motion. Fixed.

+    Expect.equals(1, C_super.superinterfaces.length);
+    Expect.isTrue(containsType(M1, [A], C_super.superinterfaces));
+    Expect.isTrue(isType(M1, [A], C_super.mixin));
+    Expect.isFalse(C_super.isObject);
+    Expect.isTrue(sameDecl(S, C_super.superclass));
+
+    Expect.isTrue(sameDecl(S, getExtends(C)));
+    Expect.isTrue(sameDeclList([M1], getWith(C)));
+    Expect.isTrue(getImplements(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.isFalse(!D_super.isNameSynthetic);
+    Expect.equals(1, D_super.superinterfaces.length);
+    Expect.isTrue(containsDecl(M2, D_super.superinterfaces));
+    Expect.isTrue(sameDecl(M2, D_super.mixin));
+    Expect.isFalse(D_super.isObject);
+    Expect.isFalse(sameDecl(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.isFalse(!D_super_super.isNameSynthetic);
+    Expect.equals(1, D_super_super.superinterfaces.length);
+    Expect.isTrue(containsDecl(M1, D_super_super.superinterfaces));
+    Expect.isTrue(sameDecl(M1, D_super_super.mixin));
+    Expect.isFalse(D_super_super.isObject);
+    Expect.isTrue(sameDecl(S, D_super_super.superclass));
+
+    Expect.isTrue(sameDecl(S, getExtends(D)));
+    Expect.isTrue(sameDeclList([M1, M2], getWith(D)));
+    Expect.isTrue(getImplements(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(containsDecl(A, E.superinterfaces));
+    Expect.isTrue(containsDecl(M1, E.superinterfaces));
+    var E_super = E.superclass;
+    Expect.isNotNull(E_super);
+    Expect.isTrue(E_super is ClassMirror);
+    Expect.isTrue(isMixinApplication(E_super));
+    Expect.isFalse(!E_super.isNameSynthetic);
+    Expect.equals(1, E_super.superinterfaces.length);
+    Expect.isTrue(containsDecl(M1, E_super.superinterfaces));
+    Expect.isTrue(sameDecl(M1, E_super.mixin));
+    Expect.isFalse(E_super.isObject);
+    Expect.isFalse(sameDecl(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.isFalse(!E_super_super.isNameSynthetic);
+    Expect.equals(1, E_super_super.superinterfaces.length);
+    Expect.isTrue(containsDecl(M2, E_super_super.superinterfaces));
+    Expect.isTrue(sameDecl(M2, E_super_super.mixin));
+    Expect.isFalse(E_super_super.isObject);
+    Expect.isTrue(sameDecl(S, E_super_super.superclass));
+
+    Expect.isTrue(sameDecl(S, getExtends(E)));
+    Expect.isTrue(sameDeclList([M2, M1], getWith(E)));
+    Expect.isTrue(sameDeclSet([A, M1], getImplements(E)));
+
+    // class E2 extends E {}
+    var E2 = library.classes['E2'];
+    Expect.isTrue(sameDecl(E, getExtends(E2)));
+    Expect.isTrue(getWith(E2).isEmpty);
+    Expect.isTrue(getImplements(E2).isEmpty);
+
+    // typedef 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.isTrue(!F.isNameSynthetic);
+    Expect.equals('F', F.simpleName);
+    Expect.isFalse(F.isObject);
+    Expect.equals(1, F.superinterfaces.length);
+    Expect.isTrue(containsDecl(M1, F.superinterfaces));
+    Expect.isTrue(isType(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(sameDecl(S, F_super));
+
+    Expect.isTrue(sameDecl(S, getExtends(F)));
+    Expect.isTrue(sameDeclList([M1], getWith(F)));
+    Expect.isTrue(getImplements(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.isTrue(!G.isNameSynthetic);
+    Expect.equals('G', G.simpleName);
+    Expect.isFalse(G.isObject);
+    Expect.equals(1, G.superinterfaces.length);
+    Expect.isTrue(containsDecl(M2, G.superinterfaces));
+    Expect.isTrue(sameDecl(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(containsDecl(M1, G_super.superinterfaces));
+    Expect.isTrue(sameDecl(M1, G_super.mixin));
+    Expect.isFalse(G_super.isObject);
+    Expect.isTrue(sameDecl(S, G_super.superclass));
+
+    Expect.isTrue(sameDecl(S, getExtends(G)));
+    Expect.isTrue(sameDeclList([M1, M2], getWith(G)));
+    Expect.isTrue(getImplements(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.isTrue(!H.isNameSynthetic);
+    Expect.equals('H', H.simpleName);
+    Expect.isFalse(H.isObject);
+    Expect.equals(3, H.superinterfaces.length);
+    Expect.isTrue(containsDecl(A, H.superinterfaces));
+    Expect.isTrue(containsDecl(M1, H.superinterfaces));
+    Expect.isFalse(containsDecl(M2, H.superinterfaces));
+    Expect.isTrue(sameDecl(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(containsDecl(M2, H_super.superinterfaces));
+    Expect.isTrue(sameDecl(M2, H_super.mixin));
+    Expect.isFalse(H_super.isObject);
+    Expect.isTrue(sameDecl(S, H_super.superclass));
+
+    Expect.isTrue(sameDecl(S, getExtends(H)));
+    Expect.isTrue(sameDeclList([M2, M1], getWith(H)));
+    Expect.isTrue(sameDeclSet([A, M1], getImplements(H)));
+
+    // class H2 extends H {}
+    var H2 = library.classes['H2'];
+    Expect.isTrue(sameDecl(H, getExtends(H2)));
+    Expect.isTrue(getWith(H2).isEmpty);
+    Expect.isTrue(getImplements(H2).isEmpty);
+  }));
+}