Align source mirrors with runtime mirrors.

tests/compiler/dart2js/mirrors_mixin_test.dart

 // 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';
 
@@ skipping 17 matching lines @@
 
 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.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);
     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.isFalse(isObject(C_super));
     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'];
+    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);
     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(isObject(D_super));
     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.isFalse(isObject(D_super_super));
     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'];
+    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));
     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(isObject(E_super));
     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.isFalse(isObject(E_super_super));
     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'];
+    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));
     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.isFalse(isObject(F_super));
     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'];
+    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));
     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.isFalse(isObject(G_super));
     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'];
+    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));
     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.isFalse(isObject(H_super));
     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'];
+    var H2 = library.declarations[#H2];
     Expect.isTrue(isSameDeclaration(H, getSuperclass(H2)));
     Expect.isTrue(getAppliedMixins(H2).isEmpty);
     Expect.isTrue(getExplicitInterfaces(H2).isEmpty);
   }));
 }