Make isEmpty a getter.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
@@ skipping 301 matching lines @@
       }
     }
     return hasNonBitOpUser(instruction, new Set<HPhi>());
   }
 
   /**
    * If the [instruction] is not `null` it will be used to attach the position
    * to the [statement].
    */
   void pushStatement(js.Statement statement, [HInstruction instruction]) {
-    assert(expressionStack.isEmpty());
+    assert(expressionStack.isEmpty);
     if (instruction != null) {
       attachLocation(statement, instruction);
     }
     currentContainer.statements.add(statement);
   }
 
   /**
    * If the [instruction] is not `null` it will be used to attach the position
    * to the [expression].
    */
@@ skipping 65 matching lines @@
     variableNames = allocator.names;
   }
 
   visitGraph(HGraph graph) {
     preGenerateMethod(graph);
     currentGraph = graph;
     indent++;  // We are already inside a function.
     subGraph = new SubGraph(graph.entry, graph.exit);
     HBasicBlock start = beginGraph(graph);
     visitBasicBlock(start);
-    if (!delayedVariableDeclarations.isEmpty()) {
+    if (!delayedVariableDeclarations.isEmpty) {
       List<js.VariableInitialization> declarations =
           <js.VariableInitialization>[];
       delayedVariableDeclarations.forEach((String name) {
         declarations.add(new js.VariableInitialization(
             new js.VariableDeclaration(name), null));
       });
       pushExpressionAsStatement(new js.VariableDeclarationList(declarations));
     }
     endGraph(graph);
   }
@@ skipping 34 matching lines @@
     do {
       HInstruction current = basicBlock.first;
       while (current != basicBlock.last) {
         // E.g, type guards.
         if (current.isControlFlow()) {
           return TYPE_STATEMENT;
         }
         // HFieldSet generates code on the form x.y = ..., which isn't
         // valid in a declaration, but it also always have no uses, so
         // it's caught by that test too.
-        assert(current is! HFieldSet || current.usedBy.isEmpty());
-        if (current.usedBy.isEmpty()) {
+        assert(current is! HFieldSet || current.usedBy.isEmpty);
+        if (current.usedBy.isEmpty) {
           result = TYPE_EXPRESSION;
         }
         current = current.next;
       }
       if (current is HGoto) {
         basicBlock = basicBlock.successors[0];
       } else if (current is HConditionalBranch) {
         if (generateAtUseSite.contains(current)) {
           // Short-circuit control flow operator trickery.
           // Check the second half, which will continue into the join.
@@ skipping 77 matching lines @@
 
     bool oldIsGeneratingExpression = isGeneratingExpression;
     isGeneratingExpression = true;
     List<js.Expression> oldExpressionStack = expressionStack;
     List<js.Expression> sequenceElements = <js.Expression>[];
     expressionStack = sequenceElements;
     HSubExpressionBlockInformation expressionSubGraph = expression;
     visitSubGraph(expressionSubGraph.subExpression);
     expressionStack = oldExpressionStack;
     isGeneratingExpression = oldIsGeneratingExpression;
-    if (sequenceElements.isEmpty()) {
+    if (sequenceElements.isEmpty) {
       // Happens when the initializer, condition or update of a loop is empty.
       return null;
     } else if (sequenceElements.length == 1) {
       return sequenceElements[0];
     } else {
       return new js.Sequence(sequenceElements);
     }
   }
 
   /**
@@ skipping 107 matching lines @@
   visitExpression(HInstruction node) {
     bool oldIsGeneratingExpression = isGeneratingExpression;
     isGeneratingExpression = true;
     visit(node);
     isGeneratingExpression = oldIsGeneratingExpression;
   }
 
   visitStatement(HInstruction node) {
     assert(!isGeneratingExpression);
     visit(node);
-    if (!expressionStack.isEmpty()) {
+    if (!expressionStack.isEmpty) {
       assert(expressionStack.length == 1);
       pushExpressionAsStatement(pop());
     }
   }
 
   void continueAsBreak(LabelElement target) {
     pushStatement(new js.Break(backend.namer.continueLabelName(target)));
   }
 
   void implicitContinueAsBreak(TargetElement target) {
@@ skipping 297 matching lines @@
         breakAction[target] = implicitBreakWithLabel;
       }
     }
 
     currentContainer = body;
     startLabeledBlock(labeledBlockInfo);
     generateStatements(labeledBlockInfo.body);
     endLabeledBlock(labeledBlockInfo);
 
     if (labeledBlockInfo.isContinue) {
-      while (!continueOverrides.isEmpty()) {
+      while (!continueOverrides.isEmpty) {
         continueAction.remove(continueOverrides.head);
         continueOverrides = continueOverrides.tail;
       }
     } else {
       breakAction.remove(labeledBlockInfo.target);
     }
 
     currentContainer = oldContainer;
     pushStatement(result);
     return true;
@@ skipping 120 matching lines @@
     }
 
     // For each copy, if the destination does not have a current
     // location, then we can safely assign to it.
     for (Copy copy in copies) {
       if (currentLocation[copy.destination] == null) {
         ready.add(copy.destination);
       }
     }
 
-    while (!worklist.isEmpty()) {
-      while (!ready.isEmpty()) {
+    while (!worklist.isEmpty) {
+      while (!ready.isEmpty) {
         String destination = ready.removeLast();
         String source = initialValue[destination];
         // Since [source] might have been updated, use the current
         // location of [source]
         String copy = currentLocation[source];
         emitAssignment(destination, copy);
         // Now [destination] is the current location of [source].
         currentLocation[source] = destination;
         // If [source] hasn't been updated and needs to have a value,
         // add it to the list of variables that can be updated. Copies
@@ skipping 155 matching lines @@
   }
 
   visitGoto(HGoto node) {
     assert(currentBlock.successors.length == 1);
     List<HBasicBlock> dominated = currentBlock.dominatedBlocks;
     // With the exception of the entry-node which dominates its successor
     // and the exit node, no block finishing with a 'goto' can have more than
     // one dominated block (since it has only one successor).
     // If the successor is dominated by another block, then the other block
     // is responsible for visiting the successor.
-    if (dominated.isEmpty()) return;
+    if (dominated.isEmpty) return;
     if (dominated.length > 2) {
       compiler.internalError('dominated.length = ${dominated.length}',
                              instruction: node);
     }
     if (dominated.length == 2 && !identical(currentBlock, currentGraph.entry)) {
       compiler.internalError('currentBlock !== currentGraph.entry',
                              instruction: node);
     }
     assert(dominated[0] == currentBlock.successors[0]);
     visitBasicBlock(dominated[0]);
@@ skipping 331 matching lines @@
 
   visitLocalSet(HLocalSet node) {
     use(node.value);
     assignVariable(variableNames.getName(node.receiver), pop());
   }
 
   visitForeign(HForeign node) {
     String code = node.code.slowToString();
     List<HInstruction> inputs = node.inputs;
     if (node.isJsStatement(types)) {
-      if (!inputs.isEmpty()) {
+      if (!inputs.isEmpty) {
         compiler.internalError("foreign statement with inputs: $code",
                                instruction: node);
       }
       pushStatement(new js.LiteralStatement(code), node);
     } else {
       List<js.Expression> data = <js.Expression>[];
       for (int i = 0; i < inputs.length; i++) {
         use(inputs[i]);
         data.add(pop());
       }
@@ skipping 1301 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }