Make isEmpty a getter.

tests/compiler/dart2js/patch_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 "../../../lib/compiler/implementation/dart2jslib.dart";
 import "../../../lib/compiler/implementation/elements/elements.dart";
 import "../../../lib/compiler/implementation/tree/tree.dart";
 import "../../../lib/compiler/implementation/util/util.dart";
 import "mock_compiler.dart";
 import "parser_helper.dart";
@@ skipping 94 matching lines @@
   return element;
 }
 
 testPatchFunction() {
   var compiler = applyPatch(
       "external test();",
       "patch test() { return 'string'; } ");
   ensure(compiler, "test", compiler.coreLibrary.find, isPatched: true);
   ensure(compiler, "test", compiler.coreLibrary.patch.find, isPatch: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty(),
+  Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testPatchMember() {
   var compiler = applyPatch(
       """
       class Class {
         external String toString();
       }
       """,
       """
       patch class Class {
         patch String toString() => 'string';
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          isMethod: false, isPatched: true);
   container.parseNode(compiler);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          isMethod: false, isPatch: true);
 
   ensure(compiler, "toString", container.lookupLocalMember,
          isPatched: true);
   ensure(compiler, "toString", container.patch.lookupLocalMember,
          isPatch: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty(),
+  Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testPatchGetter() {
   var compiler = applyPatch(
       """
       class Class {
         external int get field;
       }
       """,
       """
       patch class Class {
         patch int get field => 5;
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          isPatched: true, isMethod: false);
   container.parseNode(compiler);
   ensure(compiler,
          "field",
          container.lookupLocalMember,
          isGetter: true,
          isPatched: true);
   ensure(compiler,
          "field",
          container.patch.lookupLocalMember,
          isGetter: true,
          isPatch: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty(),
+  Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testRegularMember() {
   var compiler = applyPatch(
       """
       class Class {
         void regular() {}
       }
       """,
       """
       patch class Class {
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          isMethod: false, isPatched: true);
   container.parseNode(compiler);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          isMethod: false, isPatch: true);
 
   ensure(compiler, "regular", container.lookupLocalMember);
   ensure(compiler, "regular", container.patch.lookupLocalMember);
 
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty(),
+  Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testGhostMember() {
   var compiler = applyPatch(
       """
       class Class {
       }
       """,
       """
       patch class Class {
         void ghost() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          isMethod: false, isPatched: true);
   container.parseNode(compiler);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          isMethod: false, isPatch: true);
 
   ensure(compiler, "ghost", container.lookupLocalMember, isFound: false);
   ensure(compiler, "ghost", container.patch.lookupLocalMember);
 
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty(),
+  Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testInjectFunction() {
   var compiler = applyPatch(
       "",
       "int _function() => 5;");
   ensure(compiler,
          "_function",
          compiler.coreLibrary.find,
          isFound: false);
   ensure(compiler,
          "_function",
          compiler.coreLibrary.patch.find);
 
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty(),
+  Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testPatchSignatureCheck() {
   var compiler = applyPatch(
       """
       class Class {
         external String method1();
         external void method2(String str);
         external void method3(String s1);
@@ skipping 17 matching lines @@
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          isMethod: false, isPatched: true);
   container.ensureResolved(compiler);
   container.parseNode(compiler);
 
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method1", container.lookupLocalMember,
           isPatched: true));
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isFalse(compiler.errors.isEmpty());
+  Expect.isFalse(compiler.errors.isEmpty);
   print('method1:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method2", container.lookupLocalMember,
           isPatched: true));
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isFalse(compiler.errors.isEmpty());
+  Expect.isFalse(compiler.errors.isEmpty);
   print('method2:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method3", container.lookupLocalMember,
           isPatched: true));
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isFalse(compiler.errors.isEmpty());
+  Expect.isFalse(compiler.errors.isEmpty);
   print('method3:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method4", container.lookupLocalMember,
           isPatched: true));
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isFalse(compiler.errors.isEmpty());
+  Expect.isFalse(compiler.errors.isEmpty);
   print('method4:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method5", container.lookupLocalMember,
           isPatched: true));
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isFalse(compiler.errors.isEmpty());
+  Expect.isFalse(compiler.errors.isEmpty);
   print('method5:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method6", container.lookupLocalMember,
           isPatched: true));
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isFalse(compiler.errors.isEmpty());
+  Expect.isFalse(compiler.errors.isEmpty);
   print('method6:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method7", container.lookupLocalMember,
           isPatched: true));
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isFalse(compiler.errors.isEmpty());
+  Expect.isFalse(compiler.errors.isEmpty);
   print('method7:${compiler.errors}');
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "method8", container.lookupLocalMember,
           isPatched: true));
-  Expect.isTrue(compiler.warnings.isEmpty(),
+  Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
-  Expect.isFalse(compiler.errors.isEmpty());
+  Expect.isFalse(compiler.errors.isEmpty);
   print('method8:${compiler.errors}');
 }
 
 main() {
   testPatchFunction();
   testPatchMember();
   testPatchGetter();
   testRegularMember();
   testGhostMember();
   testInjectFunction();
   testPatchSignatureCheck();
 }