Make isEmpty a getter.

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 28 matching lines @@
   var libPath = dirPath.join(new Path.fromNative('../../../'));
   var inputPath = dirPath.join(new Path.fromNative('mirrors_helper.dart'));
   var compilation = new Compilation.library([inputPath], libPath);
   Expect.isNotNull(compilation, "No compilation created");
 
   var mirrors = compilation.mirrors;
   Expect.isNotNull(mirrors, "No mirror system returned from compilation");
 
   var libraries = mirrors.libraries;
   Expect.isNotNull(libraries, "No libraries map returned");
-  Expect.isFalse(libraries.isEmpty(), "Empty libraries map returned");
+  Expect.isFalse(libraries.isEmpty, "Empty libraries map returned");
 
   var helperLibrary = libraries["mirrors_helper"];
   Expect.isNotNull(helperLibrary, "Library 'mirrors_helper' not found");
   Expect.stringEquals("mirrors_helper", helperLibrary.simpleName,
     "Unexpected library simple name");
   Expect.stringEquals("mirrors_helper", helperLibrary.qualifiedName,
     "Unexpected library qualified name");
 
   var types = helperLibrary.types;
   Expect.isNotNull(types, "No types map returned");
-  Expect.isFalse(types.isEmpty(), "Empty types map returned");
+  Expect.isFalse(types.isEmpty, "Empty types map returned");
 
   testFoo(mirrors, helperLibrary, types);
   testBar(mirrors, helperLibrary, types);
   testBaz(mirrors, helperLibrary, types);
   // TODO(johnniwinther): Add test of class [Boz] and typedef [Func].
   // TODO(johnniwinther): Add tests of type argument substitution, which
   // is not currently implemented in dart2js.
   // TODO(johnniwinther): Add tests of Location and Source.
   testPrivate(mirrors, helperLibrary, types);
 }
@@ skipping 35 matching lines @@
   var objectType = fooClass.superclass;
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
   Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
   Expect.isTrue(containsType(fooClass,
                              computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
   var fooInterfaces = fooClass.interfaces;
   Expect.isNotNull(fooInterfaces, "Interfaces map is null");
-  Expect.isTrue(fooInterfaces.isEmpty(), "Interfaces map is not empty");
+  Expect.isTrue(fooInterfaces.isEmpty, "Interfaces map is not empty");
 
   var fooSubdeclarations = computeSubdeclarations(fooClass);
   Expect.equals(1, count(fooSubdeclarations), "Unexpected subtype count");
   for (var fooSubdeclaration in fooSubdeclarations) {
     Expect.equals(fooClass, fooSubdeclaration.superclass.declaration,
                   "Class is not superclass of subclass");
   }
 
   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(),
+  Expect.isTrue(fooClassTypeVariables.isEmpty,
                 "Type variable list is not empty");
 
   Expect.isNull(fooClass.defaultType, "Class has default type");
 
   var fooClassMembers = fooClass.declaredMembers;
   Expect.isNotNull(fooClassMembers, "Declared members map is null");
-  Expect.isTrue(fooClassMembers.isEmpty(), "Declared members map is unempty");
+  Expect.isTrue(fooClassMembers.isEmpty, "Declared members map is unempty");
 
   var fooClassConstructors = fooClass.constructors;
   Expect.isNotNull(fooClassConstructors, "Constructors map is null");
-  Expect.isTrue(fooClassConstructors.isEmpty(),
+  Expect.isTrue(fooClassConstructors.isEmpty,
                 "Constructors map is unempty");
 }
 
 // Testing interface Bar:
 //
 // interface Bar<E> {
 //
 // }
 void testBar(MirrorSystem system, LibraryMirror helperLibrary,
              Map<String,TypeMirror> types) {
@@ skipping 27 matching lines @@
   var objectType = barInterface.superclass;
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
   Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
   Expect.isTrue(containsType(barInterface,
                              computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
   var barInterfaces = barInterface.interfaces;
   Expect.isNotNull(barInterfaces, "Interfaces map is null");
-  Expect.isTrue(barInterfaces.isEmpty(), "Interfaces map is not empty");
+  Expect.isTrue(barInterfaces.isEmpty, "Interfaces map is not empty");
 
   var barSubdeclarations = computeSubdeclarations(barInterface);
   Expect.equals(1, count(barSubdeclarations), "Unexpected subtype count");
   for (var barSubdeclaration in barSubdeclarations) {
     Expect.isTrue(containsType(barInterface,
                                barSubdeclaration.interfaces),
                   "Interface is not superinterface of subclass");
   }
 
   Expect.throws(() => barInterface.typeArguments,
               (exception) => true,
               "Interface has type arguments");
   var barInterfaceTypeVariables = barInterface.typeVariables;
   Expect.isNotNull(barInterfaceTypeVariables, "Type variable list is null");
-  Expect.isFalse(barInterfaceTypeVariables.isEmpty(),
+  Expect.isFalse(barInterfaceTypeVariables.isEmpty,
                  "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.defaultType, "Interface has default type");
 
   var barInterfaceMembers = barInterface.declaredMembers;
   Expect.isNotNull(barInterfaceMembers, "Declared members map is null");
-  Expect.isTrue(barInterfaceMembers.isEmpty(),
+  Expect.isTrue(barInterfaceMembers.isEmpty,
                 "Declared members map is unempty");
 
   var barInterfaceConstructors = barInterface.constructors;
   Expect.isNotNull(barInterfaceConstructors, "Constructors map is null");
-  Expect.isTrue(barInterfaceConstructors.isEmpty(),
+  Expect.isTrue(barInterfaceConstructors.isEmpty,
                 "Constructors map is unempty");
 }
 
 // Testing class Baz:
 //
 // class Baz<E,F extends Foo> implements Bar<E> {
 //   Baz();
 //   const Baz.named();
 //   factory Baz.factory() => new Baz<E,F>();
 //
@@ skipping 36 matching lines @@
   var objectType = bazClass.superclass;
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
   Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
   Expect.isTrue(containsType(bazClass,
                              computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
   var bazInterfaces = bazClass.interfaces;
   Expect.isNotNull(bazInterfaces, "Interfaces map is null");
-  Expect.isTrue(!bazInterfaces.isEmpty(), "Interfaces map is empty");
+  Expect.isTrue(!bazInterfaces.isEmpty, "Interfaces map is empty");
   for (var bazInterface in bazInterfaces) {
     Expect.isTrue(containsType(bazClass,
                                computeSubdeclarations(objectType)),
                   "Class is not subclass of superinterface");
   }
 
   var bazSubdeclarations = computeSubdeclarations(bazClass);
   Expect.equals(0, count(bazSubdeclarations), "Unexpected subtype count");
 
   var barInterface = findMirror(bazInterfaces, "Bar");
@@ skipping 247 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.interfaces,
                    "Null interfaces map on typedef");
-  Expect.isTrue(funcTypedef.interfaces.isEmpty(),
+  Expect.isTrue(funcTypedef.interfaces.isEmpty,
                 "Non-empty interfaces map on typedef");
   Expect.isNotNull(funcTypedef.declaredMembers,
                    "Declared members map is null on type def");
-  Expect.isTrue(funcTypedef.declaredMembers.isEmpty(),
+  Expect.isTrue(funcTypedef.declaredMembers.isEmpty,
                 "Non-empty declared members map on typedef");
 
   // TODO(johnniwinther): Returned typedef should not be the declaration:
   Expect.isTrue(funcTypedef.isDeclaration, "Typedef is not declaration");
   Expect.isFalse(funcTypedef.isClass, "Typedef is class");
   Expect.isFalse(funcTypedef.isInterface, "Typedef is interface");
   Expect.isFalse(funcTypedef.isPrivate, "Typedef is private");
   Expect.isNull(funcTypedef.defaultType,
                 "Typedef default type is non-null");
   // TODO(johnniwinther): Should not throw an exception since the type should
@@ skipping 170 matching lines @@
   Expect.isTrue(privateConstructor.isConstructor);
   Expect.isTrue(privateConstructor.isPrivate);
 
   var privateFactoryConstructor =
       privateClass.declaredMembers['_PrivateClass._privateFactoryConstructor'];
   Expect.isNotNull(privateFactoryConstructor);
   Expect.isTrue(privateFactoryConstructor is MethodMirror);
   Expect.isTrue(privateFactoryConstructor.isFactory);
   Expect.isTrue(privateFactoryConstructor.isPrivate);
 }