Make isEmpty a getter.

lib/compiler/implementation/compile_time_constants.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.
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
  */
 class ConstantHandler extends CompilerTask {
@@ skipping 40 matching lines @@
     return measure(() {
       assert(work.element.kind == ElementKind.FIELD
              || work.element.kind == ElementKind.PARAMETER
              || work.element.kind == ElementKind.FIELD_PARAMETER);
       VariableElement element = work.element;
       // Shortcut if it has already been compiled.
       Constant result = initialVariableValues[element];
       if (result != null) return result;
       if (lazyStatics.contains(element)) return null;
       result = compileVariableWithDefinitions(element, work.resolutionTree);
-      assert(pendingVariables.isEmpty());
+      assert(pendingVariables.isEmpty);
       return result;
     });
   }
 
   /**
    * Returns a compile-time constant, or reports an error if the element is not
    * a compile-time constant.
    */
   Constant compileConstant(VariableElement element) {
     return compileVariable(element, isConst: true);
@@ skipping 207 matching lines @@
   Constant visitLiteralInt(LiteralInt node) {
     return constantSystem.createInt(node.value);
   }
 
   Constant visitLiteralList(LiteralList node) {
     if (!node.isConst())  {
       return signalNotCompileTimeConstant(node);
     }
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       arguments.add(evaluateConstant(link.head));
     }
     // TODO(floitsch): get type parameters.
     DartType type = new InterfaceType(compiler.listClass);
     Constant constant = new ListConstant(type, arguments);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralMap(LiteralMap node) {
     if (!node.isConst()) {
       signalNotCompileTimeConstant(node);
       error(node);
     }
     List<StringConstant> keys = <StringConstant>[];
     Map<StringConstant, Constant> map = new Map<StringConstant, Constant>();
     for (Link<Node> link = node.entries.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       LiteralMapEntry entry = link.head;
       Constant key = evaluateConstant(entry.key);
       if (!key.isString() || entry.key.asStringNode() == null) {
         MessageKind kind = MessageKind.KEY_NOT_A_STRING_LITERAL;
         compiler.reportError(entry.key, new ResolutionError(kind, const []));
       }
       StringConstant keyConstant = key;
       if (!map.containsKey(key)) keys.add(key);
       map[key] = evaluateConstant(entry.value);
@@ skipping 411 matching lines @@
    * the [fieldValues] map.
    */
   void evaluateConstructorInitializers() {
     FunctionExpression functionNode = constructor.parseNode(compiler);
     NodeList initializerList = functionNode.initializers;
 
     bool foundSuperOrRedirect = false;
 
     if (initializerList != null) {
       for (Link<Node> link = initializerList.nodes;
-           !link.isEmpty();
+           !link.isEmpty;
            link = link.tail) {
         assert(link.head is Send);
         if (link.head is !SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           FunctionElement targetConstructor = elements[call];
           Selector selector = elements.getSelector(call);
           Link<Node> arguments = call.arguments;
           evaluateSuperOrRedirectSend(
               call, selector, arguments, targetConstructor);
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> initArguments = init.arguments;
-          assert(!initArguments.isEmpty() && initArguments.tail.isEmpty());
+          assert(!initArguments.isEmpty && initArguments.tail.isEmpty);
           Constant fieldValue = evaluate(initArguments.head);
           updateFieldValue(init, elements[init], fieldValue);
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.getEnclosingClass();
@@ skipping 41 matching lines @@
             // Use the default value.
             fieldValue = compiler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeBackendMembers: true,
         includeSuperMembers: true);
     return jsNewArguments;
   }
 }