| 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
|
| index 148685145025211b1416d12c754a06d98b7e7bd5..0a94a06d6cfa5a0499f25c599f74947ced627b6a 100644
|
| --- a/tests/compiler/dart2js/mirrors_mixin_test.dart
|
| +++ b/tests/compiler/dart2js/mirrors_mixin_test.dart
|
| @@ -35,37 +35,37 @@ void main() {
|
| Expect.isTrue(cls is ClassMirror);
|
| Expect.isFalse(isMixinApplication(cls));
|
| Expect.isFalse(cls.isNameSynthetic);
|
| - Expect.isFalse(cls.isObject);
|
| - Expect.isTrue(cls.superclass.isObject);
|
| + Expect.isFalse(isObject(cls));
|
| + Expect.isTrue(isObject(cls.superclass));
|
| Expect.equals(0, cls.superinterfaces.length);
|
|
|
| - Expect.isTrue(getSuperclass(cls).isObject);
|
| + Expect.isTrue(isObject(getSuperclass(cls)));
|
| Expect.isTrue(getAppliedMixins(cls).isEmpty);
|
| Expect.isTrue(getExplicitInterfaces(cls).isEmpty);
|
| }
|
|
|
| // class A {}
|
| - var A = library.classes['A'];
|
| + var A = library.declarations[#A];
|
| checkSimpleClass(A);
|
|
|
| // class S {}
|
| - var S = library.classes['S'];
|
| + var S = library.declarations[#S];
|
| checkSimpleClass(S);
|
|
|
| // class M1 {}
|
| - var M1 = library.classes['M1'];
|
| + var M1 = library.declarations[#M1];
|
| checkSimpleClass(M1);
|
|
|
| // class M2 {}
|
| - var M2 = library.classes['M2'];
|
| + var M2 = library.declarations[#M2];
|
| checkSimpleClass(M2);
|
|
|
| // class C extends S with M1<A> {}
|
| - var C = library.classes['C'];
|
| + var C = library.declarations[#C];
|
| Expect.isNotNull(C);
|
| Expect.isTrue(C is ClassMirror);
|
| Expect.isFalse(isMixinApplication(C));
|
| - Expect.isFalse(C.isObject);
|
| + Expect.isFalse(isObject(C));
|
| Expect.equals(0, C.superinterfaces.length);
|
| var C_super = C.superclass;
|
| Expect.isNotNull(C_super);
|
| @@ -75,7 +75,7 @@ void main() {
|
| 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.isFalse(isObject(C_super));
|
| Expect.isTrue(isSameDeclaration(S, C_super.superclass));
|
|
|
| Expect.isTrue(isSameDeclaration(S, getSuperclass(C)));
|
| @@ -83,11 +83,11 @@ void main() {
|
| Expect.isTrue(getExplicitInterfaces(C).isEmpty);
|
|
|
| // D extends S with M1, M2 {}
|
| - var D = library.classes['D'];
|
| + var D = library.declarations[#D];
|
| Expect.isNotNull(D);
|
| Expect.isTrue(D is ClassMirror);
|
| Expect.isFalse(isMixinApplication(D));
|
| - Expect.isFalse(D.isObject);
|
| + Expect.isFalse(isObject(D));
|
| Expect.equals(0, D.superinterfaces.length);
|
| var D_super = D.superclass;
|
| Expect.isNotNull(D_super);
|
| @@ -97,7 +97,7 @@ void main() {
|
| 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(isObject(D_super));
|
| Expect.isFalse(isSameDeclaration(S, D_super.superclass));
|
| var D_super_super = D_super.superclass;
|
| Expect.isNotNull(D_super_super);
|
| @@ -107,7 +107,7 @@ void main() {
|
| 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.isFalse(isObject(D_super_super));
|
| Expect.isTrue(isSameDeclaration(S, D_super_super.superclass));
|
|
|
| Expect.isTrue(isSameDeclaration(S, getSuperclass(D)));
|
| @@ -115,11 +115,11 @@ void main() {
|
| Expect.isTrue(getExplicitInterfaces(D).isEmpty);
|
|
|
| // class E extends S with M2, M1 implements A, M1 {}
|
| - var E = library.classes['E'];
|
| + var E = library.declarations[#E];
|
| Expect.isNotNull(E);
|
| Expect.isTrue(E is ClassMirror);
|
| Expect.isFalse(isMixinApplication(E));
|
| - Expect.isFalse(E.isObject);
|
| + Expect.isFalse(isObject(E));
|
| Expect.equals(2, E.superinterfaces.length);
|
| Expect.isTrue(containsDeclaration(A, E.superinterfaces));
|
| Expect.isTrue(containsDeclaration(M1, E.superinterfaces));
|
| @@ -131,7 +131,7 @@ void main() {
|
| 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(isObject(E_super));
|
| Expect.isFalse(isSameDeclaration(S, E_super.superclass));
|
| var E_super_super = E_super.superclass;
|
| Expect.isNotNull(E_super_super);
|
| @@ -141,7 +141,7 @@ void main() {
|
| 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.isFalse(isObject(E_super_super));
|
| Expect.isTrue(isSameDeclaration(S, E_super_super.superclass));
|
|
|
| Expect.isTrue(isSameDeclaration(S, getSuperclass(E)));
|
| @@ -149,20 +149,20 @@ void main() {
|
| Expect.isTrue(isSameDeclarationSet([A, M1], getExplicitInterfaces(E)));
|
|
|
| // class E2 extends E {}
|
| - var E2 = library.classes['E2'];
|
| + var E2 = library.declarations[#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'];
|
| + var F = library.declarations[#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(#F, F.simpleName);
|
| + Expect.isFalse(isObject(F));
|
| Expect.equals(1, F.superinterfaces.length);
|
| Expect.isTrue(containsDeclaration(M1, F.superinterfaces));
|
| Expect.isTrue(isInstance(M1, [A], F.mixin));
|
| @@ -170,7 +170,7 @@ void main() {
|
| Expect.isNotNull(F_super);
|
| Expect.isTrue(F_super is ClassMirror);
|
| Expect.isFalse(isMixinApplication(F_super));
|
| - Expect.isFalse(F_super.isObject);
|
| + Expect.isFalse(isObject(F_super));
|
| Expect.isTrue(isSameDeclaration(S, F_super));
|
|
|
| Expect.isTrue(isSameDeclaration(S, getSuperclass(F)));
|
| @@ -178,14 +178,14 @@ void main() {
|
| Expect.isTrue(getExplicitInterfaces(F).isEmpty);
|
|
|
| // typedef G = abstract S with M1, M2;
|
| - var G = library.classes['G'];
|
| + var G = library.declarations[#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(#G, G.simpleName);
|
| + Expect.isFalse(isObject(G));
|
| Expect.equals(1, G.superinterfaces.length);
|
| Expect.isTrue(containsDeclaration(M2, G.superinterfaces));
|
| Expect.isTrue(isSameDeclaration(M2, G.mixin));
|
| @@ -196,7 +196,7 @@ void main() {
|
| 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.isFalse(isObject(G_super));
|
| Expect.isTrue(isSameDeclaration(S, G_super.superclass));
|
|
|
| Expect.isTrue(isSameDeclaration(S, getSuperclass(G)));
|
| @@ -204,14 +204,14 @@ void main() {
|
| Expect.isTrue(getExplicitInterfaces(G).isEmpty);
|
|
|
| // typedef H = S with M2, M1 implements A, M1;
|
| - var H = library.classes['H'];
|
| + var H = library.declarations[#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(#H, H.simpleName);
|
| + Expect.isFalse(isObject(H));
|
| Expect.equals(3, H.superinterfaces.length);
|
| Expect.isTrue(containsDeclaration(A, H.superinterfaces));
|
| Expect.isTrue(containsDeclaration(M1, H.superinterfaces));
|
| @@ -224,7 +224,7 @@ void main() {
|
| 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.isFalse(isObject(H_super));
|
| Expect.isTrue(isSameDeclaration(S, H_super.superclass));
|
|
|
| Expect.isTrue(isSameDeclaration(S, getSuperclass(H)));
|
| @@ -232,7 +232,7 @@ void main() {
|
| Expect.isTrue(isSameDeclarationSet([A, M1], getExplicitInterfaces(H)));
|
|
|
| // class H2 extends H {}
|
| - var H2 = library.classes['H2'];
|
| + var H2 = library.declarations[#H2];
|
| Expect.isTrue(isSameDeclaration(H, getSuperclass(H2)));
|
| Expect.isTrue(getAppliedMixins(H2).isEmpty);
|
| Expect.isTrue(getExplicitInterfaces(H2).isEmpty);
|
|
|