Make isEmpty a getter.

lib/compiler/implementation/elements/elements.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 elements;
 
 import 'dart:uri';
 
 // TODO(ahe): Rename prefix to 'api' when VM bug is fixed.
 import '../../compiler.dart' as api_e;
@@ skipping 522 matching lines @@
 
   void setPartOf(PartOf tag, DiagnosticListener listener) {
     LibraryElement library = enclosingElement;
     if (library.entryCompilationUnit == this) {
       listener.reportMessage(
           listener.spanFromNode(tag),
           MessageKind.ILLEGAL_DIRECTIVE.error(),
           api_e.Diagnostic.WARNING);
       return;
     }
-    if (!localMembers.isEmpty()) {
+    if (!localMembers.isEmpty) {
       listener.reportMessage(
           listener.spanFromNode(tag),
           MessageKind.BEFORE_TOP_LEVEL.error(),
           api_e.Diagnostic.ERROR);
       return;
     }
     if (partTag != null) {
       listener.reportMessage(
           listener.spanFromNode(tag),
           MessageKind.DUPLICATED_PART_OF.error(),
@@ skipping 280 matching lines @@
                   VariableListElement variables,
                   ElementKind kind,
                   this.cachedNode)
     : this.variables = variables,
       super(name, kind, variables.enclosingElement);
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode != null) return cachedNode;
     VariableDefinitions definitions = variables.parseNode(listener);
     for (Link<Node> link = definitions.definitions.nodes;
-         !link.isEmpty(); link = link.tail) {
+         !link.isEmpty; link = link.tail) {
       Expression initializedIdentifier = link.head;
       Identifier identifier = initializedIdentifier.asIdentifier();
       if (identifier == null) {
         identifier = initializedIdentifier.asSendSet().selector.asIdentifier();
       }
       if (identical(name, identifier.source)) {
         cachedNode = initializedIdentifier;
         return cachedNode;
       }
     }
@@ skipping 63 matching lines @@
 
   DartType computeType(Compiler compiler) {
     if (type != null) return type;
     compiler.withCurrentElement(this, () {
       VariableDefinitions node = parseNode(compiler);
       if (node.type != null) {
         type = compiler.resolveTypeAnnotation(this, node.type);
       } else {
         // Is node.definitions exactly one FunctionExpression?
         Link<Node> link = node.definitions.nodes;
-        if (!link.isEmpty() &&
+        if (!link.isEmpty &&
             link.head.asFunctionExpression() != null &&
-            link.tail.isEmpty()) {
+            link.tail.isEmpty) {
           FunctionExpression functionExpression = link.head;
           // We found exactly one FunctionExpression
           functionSignature =
               compiler.resolveFunctionExpression(this, functionExpression);
           type = compiler.computeFunctionType(compiler.functionClass,
                                               functionSignature);
         } else {
           type = compiler.types.dynamicType;
         }
       }
@@ skipping 83 matching lines @@
 
   FunctionSignature(this.requiredParameters,
                     this.optionalParameters,
                     this.requiredParameterCount,
                     this.optionalParameterCount,
                     this.optionalParametersAreNamed,
                     this.returnType);
 
   void forEachRequiredParameter(void function(Element parameter)) {
     for (Link<Element> link = requiredParameters;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       function(link.head);
     }
   }
 
   void forEachOptionalParameter(void function(Element parameter)) {
     for (Link<Element> link = optionalParameters;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       function(link.head);
     }
   }
 
   List<Element> get orderedOptionalParameters {
     if (_orderedOptionalParameters != null) return _orderedOptionalParameters;
     List<Element> list = new List<Element>.from(optionalParameters);
     if (optionalParametersAreNamed) {
       list.sort((Element a, Element b) {
@@ skipping 210 matching lines @@
    * Creates the type variables, their type and corresponding element, for the
    * type variables declared in [parameter] on [element]. The bounds of the type
    * variables are not set until [element] has been resolved.
    */
   static Link<DartType> createTypeVariables(TypeDeclarationElement element,
                                         NodeList parameters) {
     if (parameters == null) return const Link<DartType>();
 
     // Create types and elements for type variable.
     var arguments = new LinkBuilder<DartType>();
-    for (Link link = parameters.nodes; !link.isEmpty(); link = link.tail) {
+    for (Link link = parameters.nodes; !link.isEmpty; link = link.tail) {
       TypeVariable node = link.head;
       SourceString variableName = node.name.source;
       TypeVariableElement variableElement =
           new TypeVariableElement(variableName, element, node);
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.type = variableType;
       arguments.addLast(variableType);
     }
     return arguments.toLink();
   }
@@ skipping 651 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }