Make isEmpty a getter.

lib/compiler/implementation/ssa/variable_allocator.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.
 
 /**
  * The [LiveRange] class covers a range where an instruction is live.
  */
 class LiveRange {
   final int start;
   // [end] is not final because it can be updated due to loops.
@@ skipping 162 matching lines @@
   void addLoopMarker(HBasicBlock header, int id) {
     assert(!loopMarkers.containsKey(header));
     loopMarkers[header] = id;
   }
 
   void removeLoopMarker(HBasicBlock header) {
     assert(loopMarkers.containsKey(header));
     loopMarkers.remove(header);
   }
 
-  bool isEmpty() => liveInstructions.isEmpty() && loopMarkers.isEmpty();
+  bool get isEmpty => liveInstructions.isEmpty && loopMarkers.isEmpty;
   bool contains(HInstruction instruction) =>
       liveInstructions.containsKey(instruction);
   String toString() => liveInstructions.toString();
 }
 
 /**
  * Builds the live intervals of each instruction. The algorithm visits
  * the graph post-dominator tree to find the last uses of an
  * instruction, and computes the liveIns of each basic block.
  */
@@ skipping 18 matching lines @@
    * The live intervals of instructions.
    */
   final Map<HInstruction, LiveInterval> liveIntervals;
 
   SsaLiveIntervalBuilder(this.compiler, this.generateAtUseSite)
     : liveInstructions = new Map<HBasicBlock, LiveEnvironment>(),
       liveIntervals = new Map<HInstruction, LiveInterval>();
 
   void visitGraph(HGraph graph) {
     visitPostDominatorTree(graph);
-    if (!liveInstructions[graph.entry].isEmpty()) {
+    if (!liveInstructions[graph.entry].isEmpty) {
       compiler.internalError('LiveIntervalBuilder',
           node: compiler.currentElement.parseNode(compiler));
     }
   }
 
   void markInputsAsLiveInEnvironment(HInstruction instruction,
                                      LiveEnvironment environment) {
     for (int i = 0, len = instruction.inputs.length; i < len; i++) {
       markAsLiveInEnvironment(instruction.inputs[i], environment);
     }
@@ skipping 118 matching lines @@
 
   void addCopy(HInstruction source, HInstruction destination) {
     copies.add(new Copy(source, destination));
   }
 
   void addAssignment(HInstruction source, HInstruction destination) {
     assignments.add(new Copy(source, destination));
   }
 
   String toString() => 'Copies: $copies, assignments: $assignments';
-  bool isEmpty() => copies.isEmpty() && assignments.isEmpty();
+  bool get isEmpty => copies.isEmpty && assignments.isEmpty;
 }
 
 /**
  * Contains the mapping between instructions and their names for code
  * generation, as well as the [CopyHandler] for each basic block.
  */
 class VariableNames {
   final Map<HInstruction, String> ownName;
   final Map<HBasicBlock, CopyHandler> copyHandlers;
   /**
@@ skipping 79 matching lines @@
   String allocateWithHint(String originalName) {
     int i = 0;
     String name = JsNames.getValid(originalName);
     while (usedNames.contains(name)) {
       name = JsNames.getValid('$originalName${i++}');
     }
     return name;
   }
 
   String allocateTemporary() {
-    while (!freeTemporaryNames.isEmpty()) {
+    while (!freeTemporaryNames.isEmpty) {
       String name = freeTemporaryNames.removeLast();
       if (!usedNames.contains(name)) return name;
     }
     String name = 't${temporaryIndex++}';
     while (usedNames.contains(name)) name = 't${temporaryIndex++}';
     return name;
   }
 
   HPhi firstPhiUserWithElement(HInstruction instruction) {
     for (HInstruction user in instruction.usedBy) {
@@ skipping 111 matching lines @@
     block.forEachInstruction((HInstruction instruction) {
       handleInstruction(instruction, namer);
     });
   }
 
   /**
    * Returns whether [instruction] needs a name. Instructions that
    * have no users or that are generated at use site does not need a name.
    */
   bool needsName(HInstruction instruction) {
-    if (instruction.usedBy.isEmpty()) return false;
+    if (instruction.usedBy.isEmpty) return false;
     // TODO(ngeoffray): locals/parameters are being generated at use site,
     // but we need a name for them. We should probably not make
     // them generate at use site to make things simpler.
     if (instruction is HLocalValue && instruction is !HThis) return true;
     if (generateAtUseSite.contains(instruction)) return false;
     // A [HCheck] instruction that has control flow needs a name only if its
     // checked input needs a name (e.g. a check [HConstant] does not
     // need a name).
     if (instruction is HCheck && instruction.isControlFlow()) {
       HCheck check = instruction;
@@ skipping 46 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }