Make isEmpty a getter.

lib/compiler/implementation/ssa/codegen_helpers.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.
 
 /**
  * Instead of emitting each SSA instruction with a temporary variable
  * mark instructions that can be emitted at their use-site.
  * For example, in:
  *   t0 = 4;
  *   t1 = 3;
@@ skipping 114 matching lines @@
     // merged. If instructions occur in the expected order, they are
     // included in the expression.
 
     // The expectedInputs list holds non-trivial instructions that may
     // be generated at their use site, if they occur in the correct order.
     if (expectedInputs == null) expectedInputs = new List<HInstruction>();
 
     // Pop instructions from expectedInputs until instruction is found.
     // Return true if it is found, or false if not.
     bool findInInputsAndPopNonMatching(HInstruction instruction) {
-      while (!expectedInputs.isEmpty()) {
+      while (!expectedInputs.isEmpty) {
         HInstruction nextInput = expectedInputs.removeLast();
         assert(!generateAtUseSite.contains(nextInput));
         assert(nextInput.usedBy.length == 1);
         if (identical(nextInput, instruction)) {
           return true;
         }
       }
       return false;
     }
 
     block.last.accept(this);
     for (HInstruction instruction = block.last.previous;
          instruction != null;
          instruction = instruction.previous) {
       if (generateAtUseSite.contains(instruction)) {
         continue;
       }
       if (instruction.isCodeMotionInvariant()) {
         markAsGenerateAtUseSite(instruction);
         continue;
       }
       if (instruction.isJsStatement(types)) {
         expectedInputs.clear();
       }
       // See if the current instruction is the next non-trivial
       // expected input.
       if (findInInputsAndPopNonMatching(instruction)) {
         tryGenerateAtUseSite(instruction);
       } else {
-        assert(expectedInputs.isEmpty());
+        assert(expectedInputs.isEmpty);
       }
       instruction.accept(this);
     }
 
     if (block.predecessors.length == 1
         && isBlockSinglePredecessor(block.predecessors[0])) {
-      assert(block.phis.isEmpty());
+      assert(block.phis.isEmpty);
       tryMergingExpressions(block.predecessors[0]);
     } else {
       expectedInputs = null;
     }
   }
 }
 
 /**
  *  Detect control flow arising from short-circuit logical and
  *  conditional operators, and prepare the program to be generated
@@ skipping 86 matching lines @@
     //  1 expr2            |
     //    goto    goto     |
     //      \     /        |
     //       \   /         |
     //   phi1(expr2, true|false)
     //          \          |
     //           \         |
     //             phi(phi1, true|false)
 
     if (end == null) return;
-    if (end.phis.isEmpty()) return;
+    if (end.phis.isEmpty) return;
     if (!identical(end.phis.first, end.phis.last)) return;
     HBasicBlock elseBlock = startIf.elseBlock;
 
     if (!identical(end.predecessors[1], elseBlock)) return;
     HPhi phi = end.phis.first;
     HInstruction thenInput = phi.inputs[0];
     HInstruction elseInput = phi.inputs[1];
     if (thenInput.isJsStatement(types) ||
         elseInput.isJsStatement(types)) return;
 
@@ skipping 11 matching lines @@
     // have any statement and its join block is [end], we can emit a
     // sequence of control flow operation.
     if (controlFlowOperators.contains(thenBlock.last)) {
       HIf otherIf = thenBlock.last;
       if (!identical(otherIf.joinBlock, end)) {
         // This could be a join block that just feeds into our join block.
         HBasicBlock otherJoin = otherIf.joinBlock;
         if (otherJoin.first != otherJoin.last) return;
         if (otherJoin.successors.length != 1) return;
         if (otherJoin.successors[0] != end) return;
-        if (otherJoin.phis.isEmpty()) return;
+        if (otherJoin.phis.isEmpty) return;
         if (!identical(otherJoin.phis.first, otherJoin.phis.last)) return;
         HPhi otherPhi = otherJoin.phis.first;
         if (thenInput != otherPhi) return;
         if (elseInput != otherPhi.inputs[1]) return;
       }
       if (hasAnyStatement(thenBlock, otherIf)) return;
     } else {
       if (!identical(end.predecessors[0], thenBlock)) return;
       if (hasAnyStatement(thenBlock, thenInput)) return;
       assert(thenBlock.successors.length == 1);
@@ skipping 18 matching lines @@
     }
 
     // If [thenInput] is defined in the first predecessor, then it is only used
     // by [phi] and can be generated at use site.
     if (identical(thenInput.block, end.predecessors[0])) {
       assert(thenInput.usedBy.length == 1);
       markAsGenerateAtUseSite(thenInput);
     }
   }
 }