Make isEmpty a getter.

lib/compiler/implementation/tree/nodes.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.
 
 abstract class Visitor<R> {
   const Visitor();
 
   abstract R visitNode(Node node);
 
   R visitBlock(Block node) => visitStatement(node);
@@ skipping 414 matching lines @@
   Token getBeginToken() => newToken;
 
   Token getEndToken() => send.getEndToken();
 }
 
 class NodeList extends Node implements Iterable<Node> {
   final Link<Node> nodes;
   final Token beginToken;
   final Token endToken;
   final SourceString delimiter;
-  bool isEmpty() => nodes.isEmpty();
+  bool get isEmpty => nodes.isEmpty;
 
   NodeList([this.beginToken, this.nodes, this.endToken, this.delimiter]);
 
   Iterator<Node> iterator() => nodes.iterator();
 
   NodeList.singleton(Node node) : this(null, const Link<Node>().prepend(node));
   NodeList.empty() : this(null, const Link<Node>());
 
   NodeList asNodeList() => this;
 
   int length() {
     int result = 0;
-    for (Link<Node> cursor = nodes; !cursor.isEmpty(); cursor = cursor.tail) {
+    for (Link<Node> cursor = nodes; !cursor.isEmpty; cursor = cursor.tail) {
       result++;
     }
     return result;
   }
 
   accept(Visitor visitor) => visitor.visitNodeList(this);
 
   visitChildren(Visitor visitor) {
     if (nodes == null) return;
-    for (Link<Node> link = nodes; !link.isEmpty(); link = link.tail) {
+    for (Link<Node> link = nodes; !link.isEmpty; link = link.tail) {
       if (link.head != null) link.head.accept(visitor);
     }
   }
 
   Token getBeginToken() {
     if (beginToken != null) return beginToken;
      if (nodes != null) {
-       for (Link<Node> link = nodes; !link.isEmpty(); link = link.tail) {
+       for (Link<Node> link = nodes; !link.isEmpty; link = link.tail) {
          if (link.head.getBeginToken() != null) {
            return link.head.getBeginToken();
          }
          if (link.head.getEndToken() != null) {
            return link.head.getEndToken();
          }
        }
      }
     return endToken;
   }
 
   Token getEndToken() {
     if (endToken != null) return endToken;
     if (nodes != null) {
       Link<Node> link = nodes;
-      if (link.isEmpty()) return beginToken;
-      while (!link.tail.isEmpty()) link = link.tail;
+      if (link.isEmpty) return beginToken;
+      while (!link.tail.isEmpty) link = link.tail;
       if (link.head.getEndToken() != null) return link.head.getEndToken();
       if (link.head.getBeginToken() != null) return link.head.getBeginToken();
     }
     return beginToken;
   }
 }
 
 class Block extends Statement {
   final NodeList statements;
 
@@ skipping 158 matching lines @@
     if (name != null) name.accept(visitor);
     if (parameters != null) parameters.accept(visitor);
     if (initializers != null) initializers.accept(visitor);
     if (body != null) body.accept(visitor);
   }
 
   bool hasBody() {
     // TODO(karlklose,ahe): refactor AST nodes (issue 1713).
     if (body.asReturn() != null) return true;
     NodeList statements = body.asBlock().statements;
-    return (!statements.nodes.isEmpty() ||
+    return (!statements.nodes.isEmpty ||
             !identical(statements.getBeginToken().kind, $SEMICOLON));
   }
 
   Token getBeginToken() {
     Token token = firstBeginToken(modifiers, returnType);
     if (token != null) return token;
     if (getOrSet != null) return getOrSet;
     return firstBeginToken(name, parameters);
   }
 
@@ skipping 478 matching lines @@
   static const int FLAG_CONST = FLAG_VAR << 1;
   static const int FLAG_FACTORY = FLAG_CONST << 1;
   static const int FLAG_EXTERNAL = FLAG_FACTORY << 1;
 
   Modifiers(NodeList nodes) : this.withFlags(nodes, computeFlags(nodes.nodes));
 
   Modifiers.withFlags(this.nodes, this.flags);
 
   static int computeFlags(Link<Node> nodes) {
     int flags = 0;
-    for (; !nodes.isEmpty(); nodes = nodes.tail) {
+    for (; !nodes.isEmpty; nodes = nodes.tail) {
       String value = nodes.head.asIdentifier().source.stringValue;
       if (identical(value, 'static')) flags |= FLAG_STATIC;
       else if (identical(value, 'abstract')) flags |= FLAG_ABSTRACT;
       else if (identical(value, 'final')) flags |= FLAG_FINAL;
       else if (identical(value, 'var')) flags |= FLAG_VAR;
       else if (identical(value, 'const')) flags |= FLAG_CONST;
       else if (identical(value, 'factory')) flags |= FLAG_FACTORY;
       else if (identical(value, 'external')) flags |= FLAG_EXTERNAL;
       else throw 'internal error: ${nodes.head}';
     }
     return flags;
   }
 
   Node findModifier(String modifier) {
     Link<Node> nodeList = nodes.nodes;
-    for (; !nodeList.isEmpty(); nodeList = nodeList.tail) {
+    for (; !nodeList.isEmpty; nodeList = nodeList.tail) {
       String value = nodeList.head.asIdentifier().source.stringValue;
       if(identical(value, modifier)) {
         return nodeList.head;
       }
     }
     return null;
   }
 
   Modifiers asModifiers() => this;
   Token getBeginToken() => nodes.getBeginToken();
@@ skipping 297 matching lines @@
   visitChildren(Visitor visitor) {
     labelsAndCases.accept(visitor);
     statements.accept(visitor);
   }
 
   Token getBeginToken() {
     return startToken;
   }
 
   Token getEndToken() {
-    if (statements.nodes.isEmpty()) {
+    if (statements.nodes.isEmpty) {
       // All cases must have at least one expression or be the default.
       if (defaultKeyword != null) {
         // The colon after 'default'.
         return defaultKeyword.next;
       }
       // The colon after the last expression.
       return labelsAndCases.getEndToken();
     } else {
       return statements.getEndToken();
     }
@@ skipping 381 matching lines @@
   visitChildren(Visitor visitor) {
     tryBlock.accept(visitor);
     catchBlocks.accept(visitor);
     if (finallyBlock != null) finallyBlock.accept(visitor);
   }
 
   Token getBeginToken() => tryKeyword;
 
   Token getEndToken() {
     if (finallyBlock != null) return finallyBlock.getEndToken();
-    if (!catchBlocks.isEmpty()) return catchBlocks.getEndToken();
+    if (!catchBlocks.isEmpty) return catchBlocks.getEndToken();
     return tryBlock.getEndToken();
   }
 }
 
 class Cascade extends Expression {
   final Expression expression;
   Cascade(this.expression);
 
   Cascade asCascade() => this;
   accept(Visitor visitor) => visitor.visitCascade(this);
@@ skipping 33 matching lines @@
   final Token catchKeyword;
 
   CatchBlock(this.type, this.formals, this.block,
              this.onKeyword, this.catchKeyword);
 
   CatchBlock asCatchBlock() => this;
 
   accept(Visitor visitor) => visitor.visitCatchBlock(this);
 
   Node get exception {
-    if (formals == null || formals.nodes.isEmpty()) return null;
+    if (formals == null || formals.nodes.isEmpty) return null;
     VariableDefinitions declarations = formals.nodes.head;
     return declarations.definitions.nodes.head;
   }
 
   Node get trace {
-    if (formals == null || formals.nodes.isEmpty()) return null;
+    if (formals == null || formals.nodes.isEmpty) return null;
     Link<Node> declarations = formals.nodes.tail;
-    if (declarations.isEmpty()) return null;
+    if (declarations.isEmpty) return null;
     VariableDefinitions head = declarations.head;
     return head.definitions.nodes.head;
   }
 
   visitChildren(Visitor visitor) {
     if (type != null) type.accept(visitor);
     if (formals != null) formals.accept(visitor);
     block.accept(visitor);
   }
 
@@ skipping 45 matching lines @@
  * argument).
  *
  * TODO(ahe): This method is controversial, the team needs to discuss
  * if top-level methods are acceptable and what naming conventions to
  * use.
  */
 initializerDo(Node node, f(Node node)) {
   SendSet send = node.asSendSet();
   if (send != null) return f(send.arguments.head);
 }