Make isEmpty a getter.

tests/compiler/dart2js/resolver_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 'dart:uri';
 
 import "../../../lib/compiler/implementation/dart2jslib.dart"
     hide TreeElementMapping, TreeElements;
 import "../../../lib/compiler/implementation/resolution/resolution.dart";
 import "../../../lib/compiler/implementation/elements/elements.dart";
@@ skipping 70 matching lines @@
 
 testTypeVariables() {
   matchResolvedTypes(visitor, text, name, expectedElements) {
     VariableDefinitions definition = parseStatement(text);
     visitor.visit(definition.type);
     InterfaceType type = visitor.mapping.getType(definition.type);
     Expect.equals(definition.type.typeArguments.length(),
                   length(type.arguments));
     int index = 0;
     Link<DartType> arguments = type.arguments;
-    while (!arguments.isEmpty()) {
+    while (!arguments.isEmpty) {
       Expect.equals(true, index < expectedElements.length);
       Expect.equals(expectedElements[index], arguments.head.element);
       index++;
       arguments = arguments.tail;
     }
     Expect.equals(index, expectedElements.length);
   }
 
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
@@ skipping 327 matching lines @@
   compiler = new MockCompiler();
   compiler.parseScript("class Foo extends Bar {}");
   compiler.parseScript("class Bar {}");
   Map mapping = compiler.resolveStatement("Foo bar;").map;
   Expect.equals(2, mapping.length);
 
   ClassElement fooElement = compiler.mainApp.find(buildSourceString('Foo'));
   ClassElement barElement = compiler.mainApp.find(buildSourceString('Bar'));
   Expect.equals(barElement.computeType(compiler),
                 fooElement.supertype);
-  Expect.isTrue(fooElement.interfaces.isEmpty());
-  Expect.isTrue(barElement.interfaces.isEmpty());
+  Expect.isTrue(fooElement.interfaces.isEmpty);
+  Expect.isTrue(barElement.interfaces.isEmpty);
 }
 
 testVarSuperclass() {
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript("class Foo extends var {}");
   compiler.resolveStatement("Foo bar;");
   Expect.equals(1, compiler.errors.length);
   Expect.equals(
       new Message(MessageKind.CANNOT_RESOLVE_TYPE, ['var']),
       compiler.errors[0].message);
@@ skipping 13 matching lines @@
   // Add the interface to the world and make sure everything is setup correctly.
   compiler.parseScript("interface Bar {}");
 
   ResolverVisitor visitor = new ResolverVisitor(compiler, null);
   compiler.resolveStatement("Foo bar;");
 
   ClassElement fooElement = compiler.mainApp.find(buildSourceString('Foo'));
   ClassElement barElement = compiler.mainApp.find(buildSourceString('Bar'));
 
   Expect.equals(null, barElement.supertype);
-  Expect.isTrue(barElement.interfaces.isEmpty());
+  Expect.isTrue(barElement.interfaces.isEmpty);
 
   Expect.equals(barElement.computeType(compiler),
                 fooElement.interfaces.head);
   Expect.equals(1, length(fooElement.interfaces));
 }
 
 testTwoInterfaces() {
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript(
       "interface I1 {} interface I2 {} class C implements I1, I2 {}");
@@ skipping 241 matching lines @@
 
 map(ResolverVisitor visitor) {
   TreeElementMapping elements = visitor.mapping;
   return elements.map;
 }
 
 at(Link link, int index) => (index == 0) ? link.head : at(link.tail, index - 1);
 
 List<String> asSortedStrings(Link link) {
   List<String> result = <String>[];
-  for (; !link.isEmpty(); link = link.tail) result.add(link.head.toString());
+  for (; !link.isEmpty; link = link.tail) result.add(link.head.toString());
   result.sort((s1, s2) => s1.compareTo(s2));
   return result;
 }
 
 compileScript(String source) {
   Uri uri = new Uri.fromComponents(scheme: 'source');
   MockCompiler compiler = compilerFor(source, uri);
   compiler.runCompiler(uri);
   return compiler;
 }
@@ skipping 46 matching lines @@
         var d = new D();
         --d;
       }""";
   final compiler = compileScript(script);
 
   checkMemberResolved(compiler, 'A', operatorName('+', false));
   checkMemberResolved(compiler, 'B', operatorName('+', false));
   checkMemberResolved(compiler, 'C', operatorName('-', false));
   checkMemberResolved(compiler, 'D', operatorName('-', false));
 }