ObjectMirror => ContainerMirror

tests/compiler/dart2js/mirrors_test.dart

 // Copyright (c) 2012, 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.
 
 #import("../../../pkg/dartdoc/lib/mirrors.dart");
 #import("../../../pkg/dartdoc/lib/mirrors_util.dart");
 
 #import('dart:io');
 
 int count(Iterable iterable) {
@@ skipping 120 matching lines @@
   Expect.throws(() => fooClass.typeArguments,
                 (exception) => true,
                 "Class has type arguments");
   var fooClassTypeVariables = fooClass.typeVariables;
   Expect.isNotNull(fooClassTypeVariables, "Type variable list is null");
   Expect.isTrue(fooClassTypeVariables.isEmpty,
                 "Type variable list is not empty");
 
   Expect.isNull(fooClass.defaultFactory);
 
-  var fooClassMembers = fooClass.declaredMembers;
+  var fooClassMembers = fooClass.members;
   Expect.isNotNull(fooClassMembers, "Declared members map is null");
   Expect.isTrue(fooClassMembers.isEmpty, "Declared members map is unempty");
 
   var fooClassConstructors = fooClass.constructors;
   Expect.isNotNull(fooClassConstructors, "Constructors map is null");
   Expect.isTrue(fooClassConstructors.isEmpty,
                 "Constructors map is unempty");
 
   // TODO(johnniwinther): Add thorough tests of [ClassMirror.functions],
   // [ClassMirror.getters], [ClassMirror.setters], [ClassMirror.members],
@@ skipping 67 matching lines @@
                  "Type variable list is empty");
   Expect.equals(barInterfaceTypeVariables.length, 1,
                 "Unexpected number of type variables");
 
   var barE = barInterfaceTypeVariables[0];
   Expect.isNotNull(barE, "Type variable is null");
   Expect.isTrue(barE.isTypeVariable, "Type variable is not type variable");
 
   Expect.isNull(barInterface.defaultFactory);
 
-  var barInterfaceMembers = barInterface.declaredMembers;
+  var barInterfaceMembers = barInterface.members;
   Expect.isNotNull(barInterfaceMembers, "Declared members map is null");
   Expect.isTrue(barInterfaceMembers.isEmpty,
                 "Declared members map is unempty");
 
   var barInterfaceConstructors = barInterface.constructors;
   Expect.isNotNull(barInterfaceConstructors, "Constructors map is null");
   Expect.isTrue(barInterfaceConstructors.isEmpty,
                 "Constructors map is unempty");
 }
 
@@ skipping 94 matching lines @@
                       "Unexpected qualifiedName");
   Expect.equals(bazClass, bazF.declarer);
   var bazFbound = bazF.upperBound;
   Expect.isNotNull(bazFbound);
   Expect.isFalse(bazFbound.isOriginalDeclaration);
   Expect.stringEquals("mirrors_helper.Foo", bazFbound.qualifiedName,
                       "Bound is not Foo");
 
   Expect.isNull(bazClass.defaultFactory);
 
-  var bazClassMembers = bazClass.declaredMembers;
+  var bazClassMembers = bazClass.members;
   Expect.isNotNull(bazClassMembers, "Declared members map is null");
   Expect.equals(8, bazClassMembers.length,
                 "Unexpected number of declared members");
 
   ////////////////////////////////////////////////////////////////////////////
   // static method1(e) {}
   ////////////////////////////////////////////////////////////////////////////
   var method1 = bazClassMembers["method1"];
   Expect.isNotNull(method1, "method1 not found");
   Expect.stringEquals('method1', method1.simpleName,
@@ skipping 191 matching lines @@
   Expect.isFalse(funcTypedef.isVoid, "Typedef is void");
   Expect.isFalse(funcTypedef.isTypeVariable, "Typedef is a type variable");
   Expect.isTrue(funcTypedef.isTypedef, "Typedef is not a typedef");
   Expect.isFalse(funcTypedef.isFunction, "Typedef is a function");
 
   Expect.equals(helperLibrary, funcTypedef.library,
                 "Unexpected typedef library");
   Expect.isNull(funcTypedef.superclass, "Non-null superclass on typedef");
   Expect.isNotNull(funcTypedef.superinterfaces);
   Expect.isTrue(funcTypedef.superinterfaces.isEmpty);
-  Expect.isNotNull(funcTypedef.declaredMembers,
-                   "Declared members map is null on type def");
-  Expect.isTrue(funcTypedef.declaredMembers.isEmpty,
-                "Non-empty declared members map on typedef");
+  Expect.isNotNull(funcTypedef.members);
+  Expect.isTrue(funcTypedef.members.isEmpty);
 
   // TODO(johnniwinther): Returned typedef should not be the original
   // declaration:
   Expect.isTrue(funcTypedef.isOriginalDeclaration);
   Expect.isFalse(funcTypedef.isClass, "Typedef is class");
   Expect.isFalse(funcTypedef.isInterface, "Typedef is interface");
   Expect.isFalse(funcTypedef.isPrivate, "Typedef is private");
   Expect.isNull(funcTypedef.defaultFactory);
   // TODO(johnniwinther): Should not throw an exception since the type should
   // not be the original declaration.
@@ skipping 131 matching lines @@
 //   factory _PrivateClass._privateFactoryConstructor() => new _PrivateClass();
 // }
 void testPrivate(MirrorSystem system, LibraryMirror helperLibrary,
                  Map<String,TypeMirror> classes) {
   var privateClass = classes['_PrivateClass'];
   Expect.isNotNull(privateClass);
   Expect.isTrue(privateClass is ClassMirror);
   Expect.isTrue(privateClass.isClass);
   Expect.isTrue(privateClass.isPrivate);
 
-  var privateField = privateClass.declaredMembers['_privateField'];
+  var privateField = privateClass.members['_privateField'];
   Expect.isNotNull(privateField);
   Expect.isTrue(privateField is VariableMirror);
   Expect.isTrue(privateField.isPrivate);
 
-  var privateGetter = privateClass.declaredMembers['_privateGetter'];
+  var privateGetter = privateClass.members['_privateGetter'];
   Expect.isNotNull(privateGetter);
   Expect.isTrue(privateGetter is MethodMirror);
   Expect.isTrue(privateGetter.isGetter);
   Expect.isTrue(privateGetter.isPrivate);
 
-  var privateSetter = privateClass.declaredMembers['_privateSetter='];
+  var privateSetter = privateClass.members['_privateSetter='];
   Expect.isNotNull(privateSetter);
   Expect.isTrue(privateSetter is MethodMirror);
   Expect.isTrue(privateSetter.isSetter);
   Expect.isTrue(privateSetter.isPrivate);
 
-  var privateMethod = privateClass.declaredMembers['_privateMethod'];
+  var privateMethod = privateClass.members['_privateMethod'];
   Expect.isNotNull(privateMethod);
   Expect.isTrue(privateMethod is MethodMirror);
   Expect.isTrue(privateMethod.isPrivate);
 
   var privateConstructor =
-      privateClass.declaredMembers['_PrivateClass._privateConstructor'];
+      privateClass.members['_PrivateClass._privateConstructor'];
   Expect.isNotNull(privateConstructor);
   Expect.isTrue(privateConstructor is MethodMirror);
   Expect.isTrue(privateConstructor.isConstructor);
   Expect.isTrue(privateConstructor.isPrivate);
 
   var privateFactoryConstructor =
-      privateClass.declaredMembers['_PrivateClass._privateFactoryConstructor'];
+      privateClass.members['_PrivateClass._privateFactoryConstructor'];
   Expect.isNotNull(privateFactoryConstructor);
   Expect.isTrue(privateFactoryConstructor is MethodMirror);
   Expect.isTrue(privateFactoryConstructor.isFactory);
   Expect.isTrue(privateFactoryConstructor.isPrivate);
 }