Make isEmpty a getter.

lib/compiler/implementation/types/types.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.
 
 library types;
 
 import '../dart2jslib.dart' hide Selector;
 import '../tree/tree.dart';
 import '../elements/elements.dart';
 import '../util/util.dart';
@@ skipping 50 matching lines @@
         if (guaranteedType != null) return guaranteedType;
       }
       Element holder = element.enclosingElement;
       Link<Element> types = typedSends[holder];
       if (types == null) return null;
       if (!holder.isFunction()) return null;
       if (untypedElements.contains(holder)) return null;
       FunctionElement function = holder;
       FunctionSignature signature = function.computeSignature(compiler);
       for (Element parameter in signature.requiredParameters) {
-        if (types.isEmpty()) return null;
+        if (types.isEmpty) return null;
         if (element == parameter) {
           return new ConcreteType.singleton(new ClassBaseType(types.head));
         }
         types = types.tail;
       }
       return null;
     });
   }
 
   /**
@@ skipping 76 matching lines @@
     node.visitChildren(this);
     // TODO(ahe): map class?
   }
 
   visitLiteralNull(LiteralNull node) {
     recordConcreteType(node, nullClass);
   }
 
   Link<Element> computeConcreteSendArguments(Send node) {
     if (node.argumentsNode == null) return null;
-    if (node.arguments.isEmpty()) return const Link<Element>();
+    if (node.arguments.isEmpty) return const Link<Element>();
     if (node.receiver != null && concreteTypes[node.receiver] == null) {
       return null;
     }
     LinkBuilder<Element> types = new LinkBuilder<Element>();
     for (Node argument in node.arguments) {
       Element type = concreteTypes[argument];
       if (type == null) return null;
       types.addLast(type);
     }
     return types.toLink();
@@ skipping 40 matching lines @@
     task.compiler.reportWarning(node, message);
   }
 
   /**
    * Computes the pairwise Least Upper Bound (LUB) of the elements of
    * [a] and [b]. Returns [:null:] if it gives up, or if the lists
    * aren't the same length.
    */
   Link<Element> computeLubs(Link<Element> a, Link<Element> b) {
     LinkBuilder<Element> lubs = new LinkBuilder<Element>();
-    while (!a.isEmpty() && !b.isEmpty()) {
+    while (!a.isEmpty && !b.isEmpty) {
       Element lub = computeLub(a.head, b.head);
       if (lub == null) return null;
       lubs.addLast(lub);
       a = a.tail;
       b = b.tail;
     }
-    return (a.isEmpty() && b.isEmpty()) ? lubs.toLink() : null;
+    return (a.isEmpty && b.isEmpty) ? lubs.toLink() : null;
   }
 
   /**
    * Computes the Least Upper Bound (LUB) of [a] and [b]. Returns
    * [:null:] if it gives up.
    */
   Element computeLub(Element a, Element b) {
     // Fast common case, but also simple initial implementation.
     if (identical(a, b)) return a;
 
     // TODO(ahe): Improve the following "computation"...
     return null;
   }
 }