Make isEmpty a getter.

lib/compiler/implementation/ssa/optimize.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 OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 63 matching lines @@
           // version.
           // Note that we do this even if there were no guards inserted. If a
           // guard is not beneficial enough we don't emit one, but there might
           // still be speculative types on the instructions.
           new SsaTypePropagator(compiler, types),
           // Then run the [SsaCheckInserter] because the type propagator also
           // propagated types non-speculatively. For example, it might have
           // propagated the type array for a call to the List constructor.
           new SsaCheckInserter(backend, types, context.boundsChecked)];
       runPhases(graph, phases);
-      return !work.guards.isEmpty();
+      return !work.guards.isEmpty;
     });
   }
 
   void prepareForSpeculativeOptimizations(WorkItem work, HGraph graph) {
     JavaScriptItemCompilationContext context = work.compilationContext;
     HTypeMap types = context.types;
     measure(() {
       // In order to generate correct code for the bailout version, we did not
       // propagate types from the instruction to the type guard. We do it
       // now to be able to optimize further.
@@ skipping 637 matching lines @@
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
   final HTypeMap types;
   final String name = "SsaDeadCodeEliminator";
 
   SsaDeadCodeEliminator(this.types);
 
   bool isDeadCode(HInstruction instruction) {
     return !instruction.hasSideEffects(types)
-           && instruction.usedBy.isEmpty()
+           && instruction.usedBy.isEmpty
            // A dynamic getter that has no side effect can still throw
            // a NoSuchMethodError or a NullPointerException.
            && instruction is !HInvokeDynamicGetter
            && instruction is !HCheck
            && instruction is !HTypeGuard
            && !instruction.isControlFlow();
   }
 
   void visitGraph(HGraph graph) {
     visitPostDominatorTree(graph);
@@ skipping 25 matching lines @@
           if (user is !HPhi) {
             worklist.add(phi);
             livePhis.add(phi);
             break;
           }
         }
       });
     }
 
     // Process the worklist by propagating liveness to phi inputs.
-    while (!worklist.isEmpty()) {
+    while (!worklist.isEmpty) {
       HPhi phi = worklist.removeLast();
       for (final input in phi.inputs) {
         if (input is HPhi && !livePhis.contains(input)) {
           worklist.add(input);
           livePhis.add(input);
         }
       }
     }
 
     // Remove phis that are not live.
     // Traverse in reverse order to remove phis with no uses before the
     // phis that they might use.
     // NOTICE: Doesn't handle circular references, but we don't currently
     // create any.
     List<HBasicBlock> blocks = graph.blocks;
     for (int i = blocks.length - 1; i >= 0; i--) {
       HBasicBlock block = blocks[i];
       HPhi current = block.phis.first;
       HPhi next = null;
       while (current != null) {
         next = current.next;
         if (!livePhis.contains(current)
             // TODO(ahe): Not sure the following is correct.
-            && current.usedBy.isEmpty()) {
+            && current.usedBy.isEmpty) {
           block.removePhi(current);
         }
         current = next;
       }
     }
   }
 }
 
 class SsaRedundantPhiEliminator implements OptimizationPhase {
   final String name = "SsaRedundantPhiEliminator";
 
   void visitGraph(HGraph graph) {
     final List<HPhi> worklist = <HPhi>[];
 
     // Add all phis in the worklist.
     for (final block in graph.blocks) {
       block.forEachPhi((HPhi phi) => worklist.add(phi));
     }
 
-    while (!worklist.isEmpty()) {
+    while (!worklist.isEmpty) {
       HPhi phi = worklist.removeLast();
 
       // If the phi has already been processed, continue.
       if (!phi.isInBasicBlock()) continue;
 
       // Find if the inputs of the phi are the same instruction.
       // The builder ensures that phi.inputs[0] cannot be the phi
       // itself.
       assert(!identical(phi.inputs[0], phi));
       HInstruction candidate = phi.inputs[0];
@@ skipping 122 matching lines @@
     for (int i = 0, length = dominatedBlocks.length; i < length; i++) {
       HBasicBlock dominated = dominatedBlocks[i];
       // No need to copy the value set for the last child.
       ValueSet successorValues = (i == length - 1) ? values : values.copy();
       // If we have no values in our set, we do not have to kill
       // anything. Also, if the range of block ids from the current
       // block to the dominated block is empty, there is no blocks on
       // any path from the current block to the dominated block so we
       // don't have to do anything either.
       assert(block.id < dominated.id);
-      if (!successorValues.isEmpty() && block.id + 1 < dominated.id) {
+      if (!successorValues.isEmpty && block.id + 1 < dominated.id) {
         visited.clear();
         int changesFlags = getChangesFlagsForDominatedBlock(block, dominated);
         successorValues.kill(changesFlags);
       }
       visitBasicBlock(dominated, successorValues);
     }
   }
 
   void computeChangesFlags(HGraph graph) {
     // Create the changes flags lists. Make sure to initialize the
@@ skipping 90 matching lines @@
     // Phase 1: get the ValueSet of all successors (if there are more than one),
     // compute the intersection and move the instructions of the intersection
     // into this block.
     if (successors.length > 1) {
       ValueSet instructions = values[successors[0].id];
       for (int i = 1; i < successors.length; i++) {
         ValueSet other = values[successors[i].id];
         instructions = instructions.intersection(other);
       }
 
-      if (!instructions.isEmpty()) {
+      if (!instructions.isEmpty) {
         List<HInstruction> list = instructions.toList();
         for (HInstruction instruction in list) {
           // Move the instruction to the current block.
           instruction.block.detach(instruction);
           block.moveAtExit(instruction);
           // Go through all successors and rewrite their instruction
           // to the shared one.
           for (final successor in successors) {
             HInstruction toRewrite = values[successor.id].lookup(instruction);
             if (toRewrite != instruction) {
@@ skipping 54 matching lines @@
     visitDominatorTree(graph);
   }
 
 
   // Update users of [input] that are dominated by [:dominator.first:]
   // to use [newInput] instead.
   void changeUsesDominatedBy(HBasicBlock dominator,
                              HInstruction input,
                              HType convertedType) {
     Set<HInstruction> dominatedUsers = input.dominatedUsers(dominator.first);
-    if (dominatedUsers.isEmpty()) return;
+    if (dominatedUsers.isEmpty) return;
 
     HTypeConversion newInput = new HTypeConversion(convertedType, input);
     dominator.addBefore(dominator.first, newInput);
     dominatedUsers.forEach((HInstruction user) {
       user.changeUse(input, newInput);
     });
   }
 
   void visitIs(HIs instruction) {
     HInstruction input = instruction.expression;
     HType convertedType =
         new HType.fromBoundedType(instruction.typeExpression, compiler);
 
     List<HInstruction> ifUsers = <HInstruction>[];
     List<HInstruction> notIfUsers = <HInstruction>[];
 
     for (HInstruction user in instruction.usedBy) {
       if (user is HIf) {
         ifUsers.add(user);
       } else if (user is HNot) {
         for (HInstruction notUser in user.usedBy) {
           if (notUser is HIf) notIfUsers.add(notUser);
         }
       }
     }
 
-    if (ifUsers.isEmpty() && notIfUsers.isEmpty()) return;
+    if (ifUsers.isEmpty && notIfUsers.isEmpty) return;
 
     for (HIf ifUser in ifUsers) {
       changeUsesDominatedBy(ifUser.thenBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the else block on a HType
       // that knows it is not of a specific Type.
     }
 
     for (HIf ifUser in notIfUsers) {
       changeUsesDominatedBy(ifUser.elseBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the then block on a HType
@@ skipping 138 matching lines @@
     }
 
     // For other fields having setters in the generative constructor body, set
     // the type to UNKNOWN to avoid relying on the type set in the initializer
     // list.
     allSetters.forEach((Element element) {
       backend.registerFieldConstructor(element, HType.UNKNOWN);
     });
   }
 }