Make isEmpty a getter.

lib/compiler/implementation/closure.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 closureToClassMapper;
 
 import "elements/elements.dart";
 import "dart2jslib.dart";
 import "tree/tree.dart";
 import "util/util.dart";
@@ skipping 97 matching lines @@
   Element boxElement;
   Map<Element, Element> capturedVariableMapping;
   // If the scope is attached to a [For] contains the variables that are
   // declared in the initializer of the [For] and that need to be boxed.
   // Otherwise contains the empty List.
   List<Element> boxedLoopVariables;
 
   ClosureScope(this.boxElement, this.capturedVariableMapping)
       : boxedLoopVariables = const <Element>[];
 
-  bool hasBoxedLoopVariables() => !boxedLoopVariables.isEmpty();
+  bool hasBoxedLoopVariables() => !boxedLoopVariables.isEmpty;
 }
 
 class ClosureClassMap {
   // The closure's element before any translation. Will be null for methods.
   final Element closureElement;
   // The closureClassElement will be null for methods that are not local
   // closures.
   final ClassElement closureClassElement;
   // The callElement will be null for methods that are not local closures.
   final FunctionElement callElement;
@@ skipping 114 matching lines @@
           fieldCaptures.add(updatedElement);
         } else {
           // A boxed element.
           freeVariableMapping[fromElement] = updatedElement;
           Element boxElement = updatedElement.enclosingElement;
           assert(boxElement.kind == ElementKind.VARIABLE);
           fieldCaptures.add(boxElement);
         }
       });
       ClassElement closureElement = data.closureClassElement;
-      assert(closureElement != null || fieldCaptures.isEmpty());
+      assert(closureElement != null || fieldCaptures.isEmpty);
       for (Element capturedElement in fieldCaptures) {
         SourceString name;
         if (capturedElement is BoxElement) {
           // The name is already mangled.
           name = capturedElement.name;
         } else {
           int id = closureFieldCounter++;
           name = new SourceString("${capturedElement.name.slowToString()}_$id");
         }
         Element fieldElement = new ClosureFieldElement(name, closureElement);
@@ skipping 31 matching lines @@
   void declareLocal(Element element) {
     scopeVariables.add(element);
   }
 
   visit(Node node) => node.accept(this);
 
   visitNode(Node node) => node.visitChildren(this);
 
   visitVariableDefinitions(VariableDefinitions node) {
     for (Link<Node> link = node.definitions.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       Node definition = link.head;
       Element element = elements[definition];
       assert(element != null);
       declareLocal(element);
       // We still need to visit the right-hand sides of the init-assignments.
       // For SendSets don't visit the left again. Otherwise it would be marked
       // as mutated.
       if (definition is Send) {
         Send assignment = definition;
@@ skipping 113 matching lines @@
         // We are currently using the name in an HForeign which could replace
         // "$X" with something else.
         String escaped = elementName.replaceAll("\$", "_");
         SourceString boxedName =
             new SourceString("${escaped}_${closureFieldCounter++}");
         Element boxed = new Element(boxedName, ElementKind.FIELD, box);
         scopeMapping[element] = boxed;
         capturedVariableMapping[element] = boxed;
       }
     }
-    if (!scopeMapping.isEmpty()) {
+    if (!scopeMapping.isEmpty) {
       ClosureScope scope = new ClosureScope(box, scopeMapping);
       closureData.capturingScopes[node] = scope;
     }
   }
 
   void inNewScope(Node node, Function action) {
     List<Element> oldScopeVariables = scopeVariables;
     scopeVariables = new List<Element>();
     action();
     attachCapturedScopeVariables(node);
@@ skipping 12 matching lines @@
   visitFor(For node) {
     visitLoop(node);
     // See if we have declared loop variables that need to be boxed.
     if (node.initializer == null) return;
     VariableDefinitions definitions = node.initializer.asVariableDefinitions();
     if (definitions == null) return;
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     List<Element> result = <Element>[];
     for (Link<Node> link = definitions.definitions.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       Node definition = link.head;
       Element element = elements[definition];
       if (capturedVariableMapping.containsKey(element)) {
         result.add(element);
       };
     }
     scopeData.boxedLoopVariables = result;
   }
 
@@ skipping 97 matching lines @@
     bool savedInsideClosure = insideClosure;
 
     // Restore old values.
     insideClosure = oldInsideClosure;
     closureData = oldClosureData;
     currentElement = oldFunctionElement;
 
     // Mark all free variables as captured and use them in the outer function.
     List<Element> freeVariables =
         savedClosureData.freeVariableMapping.getKeys();
-    assert(freeVariables.isEmpty() || savedInsideClosure);
+    assert(freeVariables.isEmpty || savedInsideClosure);
     for (Element freeElement in freeVariables) {
       if (capturedVariableMapping[freeElement] != null &&
           capturedVariableMapping[freeElement] != freeElement) {
         compiler.internalError('In closure analyzer', node: node);
       }
       capturedVariableMapping[freeElement] = freeElement;
       useLocal(freeElement);
     }
   }
 
@@ skipping 23 matching lines @@
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }