Make isEmpty a getter.

lib/compiler/implementation/scanner/listener.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.
 
 const bool VERBOSE = false;
 
 /**
  * A parser event listener that does nothing except throw exceptions
  * on parser errors.
  */
@@ skipping 636 matching lines @@
                       node: node);
       return null;
     }
     return node;
   }
 
   bool allowLibraryTags() {
     // Library tags are only allowed in the library file itself, not
     // in sourced files.
     LibraryElement library = compilationUnitElement.getLibrary();
-    return compilationUnitElement.localMembers.isEmpty()
+    return compilationUnitElement.localMembers.isEmpty
       && library.entryCompilationUnit == compilationUnitElement;
   }
 
   void endLibraryName(Token libraryKeyword, Token semicolon) {
     Expression name = popNode();
     addLibraryTag(new LibraryName(libraryKeyword, name));
   }
 
   void endImport(Token importKeyword, Token asKeyword, Token semicolon) {
     NodeList combinators = popNode();
@@ skipping 167 matching lines @@
                           NodeList variables,
                           ContainerElement enclosingElement,
                           void buildFieldElement(SourceString name,
                                                  Element fields),
                           Token beginToken, Token endToken) {
     Element fields = new PartialFieldListElement(beginToken,
                                                  endToken,
                                                  modifiers,
                                                  enclosingElement);
     for (Link<Node> variableNodes = variables.nodes;
-         !variableNodes.isEmpty();
+         !variableNodes.isEmpty;
          variableNodes = variableNodes.tail) {
       Expression initializedIdentifier = variableNodes.head;
       Identifier identifier = initializedIdentifier.asIdentifier();
       if (identifier == null) {
         identifier = initializedIdentifier.asSendSet().selector.asIdentifier();
       }
       SourceString name = identifier.source;
       buildFieldElement(name, fields);
     }
   }
@@ skipping 127 matching lines @@
   Token unmatched(Token token) {
     listener.cancel("unmatched '${token.slowToString()}'", token: token);
     return skipToEof(token);
   }
 
   void recoverableError(String message, {Token token, Node node}) {
     listener.cancel(message, token: token, node: node);
   }
 
   void pushElement(Element element) {
-    for (Link link = metadata; !link.isEmpty(); link = link.tail) {
+    for (Link link = metadata; !link.isEmpty; link = link.tail) {
       element.addMetadata(link.head);
     }
     metadata = const Link<MetadataAnnotation>();
     compilationUnitElement.addMember(element, listener);
   }
 
   void pushMetadata(MetadataAnnotation annotation) {
     metadata = metadata.prepend(annotation);
   }
 
   void addScriptTag(ScriptTag tag) {
     // TODO(ahe): Remove this method.
     addLibraryTag(tag.toLibraryTag());
   }
 
   void addLibraryTag(LibraryTag tag) {
     if (!allowLibraryTags()) {
       recoverableError('library tags not allowed here', node: tag);
     }
     compilationUnitElement.getImplementationLibrary().addTag(tag, listener);
   }
 
   void pushNode(Node node) {
     nodes = nodes.prepend(node);
     if (VERBOSE) log("push $nodes");
   }
 
   Node popNode() {
-    assert(!nodes.isEmpty());
+    assert(!nodes.isEmpty);
     Node node = nodes.head;
     nodes = nodes.tail;
     if (VERBOSE) log("pop $nodes");
     return node;
   }
 
   Node peekNode() {
-    assert(!nodes.isEmpty());
+    assert(!nodes.isEmpty);
     Node node = nodes.head;
     if (VERBOSE) log("peek $node");
     return node;
   }
 
   void log(message) {
     print(message);
   }
 
   NodeList makeNodeList(int count, Token beginToken, Token endToken,
@@ skipping 865 matching lines @@
     return cachedNode;
   }
 }
 
 Node parse(DiagnosticListener diagnosticListener,
            CompilationUnitElement element,
            doParse(Parser parser)) {
   NodeListener listener = new NodeListener(diagnosticListener, element);
   doParse(new Parser(listener));
   Node node = listener.popNode();
-  assert(listener.nodes.isEmpty());
+  assert(listener.nodes.isEmpty);
   return node;
 }