Make isEmpty a getter.

lib/compiler/implementation/ssa/nodes.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 HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 347 matching lines @@
     HInstruction last = end.last;
     if (last is HConditionalBranch || last is HSwitch) return last.inputs[0];
     return null;
   }
 }
 
 class HInstructionList {
   HInstruction first = null;
   HInstruction last = null;
 
-  bool isEmpty() {
+  bool get isEmpty {
     return first == null;
   }
 
   void addAfter(HInstruction cursor, HInstruction instruction) {
     if (cursor == null) {
-      assert(isEmpty());
+      assert(isEmpty);
       first = last = instruction;
     } else if (identical(cursor, last)) {
       last.next = instruction;
       instruction.previous = last;
       last = instruction;
     } else {
       instruction.previous = cursor;
       instruction.next = cursor.next;
       cursor.next.previous = instruction;
       cursor.next = instruction;
     }
   }
 
   void addBefore(HInstruction cursor, HInstruction instruction) {
     if (cursor == null) {
-      assert(isEmpty());
+      assert(isEmpty);
       first = last = instruction;
     } else if (identical(cursor, first)) {
       first.previous = instruction;
       instruction.next = first;
       first = instruction;
     } else {
       instruction.next = cursor;
       instruction.previous = cursor.previous;
       cursor.previous.next = instruction;
       cursor.previous = instruction;
@@ skipping 11 matching lines @@
     if (instruction.next == null) {
       last = instruction.previous;
     } else {
       instruction.next.previous = instruction.previous;
     }
     instruction.previous = null;
     instruction.next = null;
   }
 
   void remove(HInstruction instruction) {
-    assert(instruction.usedBy.isEmpty());
+    assert(instruction.usedBy.isEmpty);
     detach(instruction);
   }
 
   /** Linear search for [instruction]. */
   bool contains(HInstruction instruction) {
     HInstruction cursor = first;
     while (cursor != null) {
       if (identical(cursor, instruction)) return true;
       cursor = cursor.next;
     }
@@ skipping 48 matching lines @@
 
   bool isLabeledBlock() =>
     blockFlow != null &&
     blockFlow.body is HLabeledBlockInformation;
 
   HBasicBlock get enclosingLoopHeader {
     if (isLoopHeader()) return this;
     return parentLoopHeader;
   }
 
-  bool hasBailoutTargets() => !bailoutTargets.isEmpty();
+  bool hasBailoutTargets() => !bailoutTargets.isEmpty;
 
   void open() {
     assert(isNew());
     status = STATUS_OPEN;
   }
 
   void close(HControlFlow end) {
     assert(isOpen());
     addAfter(last, end);
     status = STATUS_CLOSED;
@@ skipping 72 matching lines @@
 
   void remove(HInstruction instruction) {
     assert(isOpen() || isClosed());
     assert(instruction is !HPhi);
     super.remove(instruction);
     assert(instruction.block == this);
     instruction.notifyRemovedFromBlock();
   }
 
   void addSuccessor(HBasicBlock block) {
-    if (successors.isEmpty()) {
+    if (successors.isEmpty) {
       successors = [block];
     } else {
       successors.add(block);
     }
     block.predecessors.add(this);
   }
 
   void postProcessLoopHeader() {
     assert(isLoopHeader());
     // Only the first entry into the loop is from outside the
@@ skipping 21 matching lines @@
    * information on [to], and that dominates the user.
    */
   void rewriteWithBetterUser(HInstruction from, HInstruction to) {
     Link<HCheck> better = const Link<HCheck>();
     for (HInstruction user in to.usedBy) {
       if (user is HCheck && identical((user as HCheck).checkedInput, to)) {
         better = better.prepend(user);
       }
     }
 
-    if (better.isEmpty()) return rewrite(from, to);
+    if (better.isEmpty) return rewrite(from, to);
 
     L1: for (HInstruction user in from.usedBy) {
       for (HCheck check in better) {
         if (check.dominates(user)) {
           user.rewriteInput(from, check);
           check.usedBy.add(user);
           continue L1;
         }
       }
       user.rewriteInput(from, to);
@@ skipping 341 matching lines @@
     for (int i = 0; i < inputs.length; i++) {
       assert(inputs[i].isInBasicBlock());
       inputs[i].usedBy.add(this);
     }
     block = targetBlock;
     assert(isValid());
   }
 
   void notifyRemovedFromBlock() {
     assert(isInBasicBlock());
-    assert(usedBy.isEmpty());
+    assert(usedBy.isEmpty);
 
     // Remove [this] from the inputs' uses.
     for (int i = 0; i < inputs.length; i++) {
       inputs[i].removeUser(this);
     }
     this.block = null;
     assert(isValid());
   }
 
   void rewriteInput(HInstruction from, HInstruction to) {
@@ skipping 1968 matching lines @@
   HSwitchBlockInformation(this.expression,
                           this.matchExpressions,
                           this.statements,
                           this.hasDefault,
                           this.target,
                           this.labels);
 
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
-    assert(!statements.isEmpty());
+    assert(!statements.isEmpty);
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }