Make isEmpty a getter.

lib/compiler/implementation/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 930 matching lines @@
     assert(elements[function] != null);
     openFunction(functionElement, function);
     function.body.accept(this);
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     SendSet node = variable.parseNode(compiler);
     openFunction(variable, node);
     Link<Node> link = node.arguments;
-    assert(!link.isEmpty() && link.tail.isEmpty());
+    assert(!link.isEmpty && link.tail.isEmpty);
     visit(link.head);
     HInstruction value = pop();
     value = potentiallyCheckType(value, variable);
     close(new HReturn(value)).addSuccessor(graph.exit);
     return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
     assert(constructor.isGenerativeConstructor());
     assert(invariant(constructor, constructor.isImplementation));
     if (constructor is SynthesizedConstructorElement) return null;
     FunctionExpression node = constructor.parseNode(compiler);
     // If we know the body doesn't have any code, we don't generate it.
     if (node.body.asBlock() != null) {
       NodeList statements = node.body.asBlock().statements;
-      if (statements.isEmpty()) return null;
+      if (statements.isEmpty) return null;
     }
     ClassElement classElement = constructor.getEnclosingClass();
     ConstructorBodyElement bodyElement;
     for (Link<Element> backendMembers = classElement.backendMembers;
-         !backendMembers.isEmpty();
+         !backendMembers.isEmpty;
          backendMembers = backendMembers.tail) {
       Element backendMember = backendMembers.head;
       if (backendMember.isGenerativeConstructorBody()) {
         ConstructorBodyElement body = backendMember;
         if (body.constructor == constructor) {
           bodyElement = backendMember;
           break;
         }
       }
     }
@@ skipping 191 matching lines @@
   void buildInitializers(FunctionElement constructor,
                          List<FunctionElement> constructors,
                          Map<Element, HInstruction> fieldValues) {
     assert(invariant(constructor, constructor.isImplementation));
     FunctionExpression functionNode = constructor.parseNode(compiler);
 
     bool foundSuperOrRedirect = false;
 
     if (functionNode.initializers != null) {
       Link<Node> initializers = functionNode.initializers.nodes;
-      for (Link<Node> link = initializers; !link.isEmpty(); link = link.tail) {
+      for (Link<Node> link = initializers; !link.isEmpty; link = link.tail) {
         assert(link.head is Send);
         if (link.head is !SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           assert(Initializers.isSuperConstructorCall(call) ||
                  Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call];
           Selector selector = elements.getSelector(call);
           Link<Node> arguments = call.arguments;
           inlineSuperOrRedirect(target, selector, arguments, constructors,
                                 fieldValues);
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> arguments = init.arguments;
-          assert(!arguments.isEmpty() && arguments.tail.isEmpty());
+          assert(!arguments.isEmpty && arguments.tail.isEmpty);
           sourceElementStack.add(constructor);
           visit(arguments.head);
           sourceElementStack.removeLast();
           fieldValues[elements[init]] = pop();
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
@@ skipping 370 matching lines @@
     }
     return location;
 }
 
   void visit(Node node) {
     if (node != null) node.accept(this);
   }
 
   visitBlock(Block node) {
     for (Link<Node> link = node.statements.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       if (isAborted()) {
         // The block has been aborted by a return or a throw.
-        if (!stack.isEmpty()) compiler.cancel('non-empty instruction stack');
+        if (!stack.isEmpty) compiler.cancel('non-empty instruction stack');
         return;
       }
     }
     assert(!current.isClosed());
-    if (!stack.isEmpty()) compiler.cancel('non-empty instruction stack');
+    if (!stack.isEmpty) compiler.cancel('non-empty instruction stack');
   }
 
   visitClassNode(ClassNode node) {
     compiler.internalError('visitClassNode should not be called', node: node);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visit(node.expression);
     pop();
   }
@@ skipping 31 matching lines @@
     HBasicBlock loopExitBlock = addNewBlock();
     assert(branchBlock.successors.length == 1);
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(loopExitBlock);
       breakLocals.add(locals);
     });
     branchBlock.addSuccessor(loopExitBlock);
     open(loopExitBlock);
     localsHandler.endLoop(loopEntry);
-    if (!breakLocals.isEmpty()) {
+    if (!breakLocals.isEmpty) {
       breakLocals.add(savedLocals);
       localsHandler = savedLocals.mergeMultiple(breakLocals, loopExitBlock);
     } else {
       localsHandler = savedLocals;
     }
   }
 
   HSubGraphBlockInformation wrapStatementGraph(SubGraph statements) {
     if (statements == null) return null;
     return new HSubGraphBlockInformation(statements);
@@ skipping 73 matching lines @@
     bodyBlock.addSuccessor(updateBlock);
     continueLocals.add(localsHandler);
 
     open(updateBlock);
 
     localsHandler = localsHandler.mergeMultiple(continueLocals, updateBlock);
 
     HLabeledBlockInformation labelInfo;
     List<LabelElement> labels = jumpHandler.labels();
     TargetElement target = elements[loop];
-    if (!labels.isEmpty()) {
+    if (!labels.isEmpty) {
       beginBodyBlock.setBlockFlow(
           new HLabeledBlockInformation(
               new HSubGraphBlockInformation(bodyGraph),
               jumpHandler.labels(),
               isContinue: true),
           updateBlock);
     } else if (target != null && target.isContinueTarget) {
       beginBodyBlock.setBlockFlow(
           new HLabeledBlockInformation.implicit(
               new HSubGraphBlockInformation(bodyGraph),
@@ skipping 101 matching lines @@
     // block. This could also lead to a block having multiple entries and exits.
     HBasicBlock bodyExitBlock = close(new HGoto());
     HBasicBlock conditionBlock = addNewBlock();
 
     List<LocalsHandler> continueLocals = <LocalsHandler>[];
     jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(conditionBlock);
       continueLocals.add(locals);
     });
     bodyExitBlock.addSuccessor(conditionBlock);
-    if (!continueLocals.isEmpty()) {
+    if (!continueLocals.isEmpty) {
       continueLocals.add(localsHandler);
       localsHandler = savedLocals.mergeMultiple(continueLocals, conditionBlock);
       SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
       List<LabelElement> labels = jumpHandler.labels();
       HSubGraphBlockInformation bodyInfo =
           new HSubGraphBlockInformation(bodyGraph);
       HLabeledBlockInformation info;
-      if (!labels.isEmpty()) {
+      if (!labels.isEmpty) {
         info = new HLabeledBlockInformation(bodyInfo, labels, isContinue: true);
       } else {
         info = new HLabeledBlockInformation.implicit(bodyInfo, target,
                                                      isContinue: true);
       }
       bodyEntryBlock.setBlockFlow(info, conditionBlock);
     }
     open(conditionBlock);
 
     visit(node.condition);
@@ skipping 32 matching lines @@
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     assert(nestedClosureData != null);
     assert(nestedClosureData.closureClassElement != null);
     ClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     FunctionElement callElement = nestedClosureData.callElement;
     // TODO(ahe): This should be registered in codegen, not here.
     compiler.enqueuer.codegen.addToWorkList(callElement, elements);
     // TODO(ahe): This should be registered in codegen, not here.
     compiler.enqueuer.codegen.registerInstantiatedClass(closureClassElement);
-    assert(closureClassElement.localScope.isEmpty());
+    assert(closureClassElement.localScope.isEmpty);
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     for (Element member in closureClassElement.backendMembers) {
       // The backendMembers also contains the call method(s). We are only
       // interested in the fields.
       if (member.isField()) {
         Element capturedLocal = nestedClosureData.capturedFieldMapping[member];
         assert(capturedLocal != null);
         capturedVariables.add(localsHandler.readLocal(capturedLocal));
       }
@@ skipping 440 matching lines @@
            arguments = arguments.tail, i++) {
         visit(arguments.head);
         list.add(pop());
       }
 
       // Visit named arguments and add them into a temporary map.
       Map<SourceString, HInstruction> instructions =
           new Map<SourceString, HInstruction>();
       List<SourceString> namedArguments = selector.namedArguments;
       int nameIndex = 0;
-      for (; !arguments.isEmpty(); arguments = arguments.tail) {
+      for (; !arguments.isEmpty; arguments = arguments.tail) {
         visit(arguments.head);
         instructions[namedArguments[nameIndex++]] = pop();
       }
 
       // Iterate through the named arguments to add them to the list
       // of instructions, in an order that can be shared with
       // selectors with the same named arguments.
       List<SourceString> orderedNames = selector.getOrderedNamedArguments();
       for (SourceString name in orderedNames) {
         list.add(instructions[name]);
@@ skipping 31 matching lines @@
 
     return selector.addArgumentsToList(arguments,
                                        list,
                                        element,
                                        compileArgument,
                                        compileConstant,
                                        compiler);
   }
 
   void addGenericSendArgumentsToList(Link<Node> link, List<HInstruction> list) {
-    for (; !link.isEmpty(); link = link.tail) {
+    for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
   visitDynamicSend(Send node) {
     Selector selector = elements.getSelector(node);
     var inputs = <HInstruction>[];
 
     SourceString dartMethodName;
     bool isNotEquals = false;
-    if (node.isIndex && !node.arguments.tail.isEmpty()) {
+    if (node.isIndex && !node.arguments.tail.isEmpty) {
       dartMethodName = Elements.constructOperatorName(
           const SourceString('[]='), false);
     } else if (node.selector.asOperator() != null) {
       SourceString name = node.selector.asIdentifier().source;
       isNotEquals = identical(name.stringValue, '!=');
       dartMethodName = Elements.constructOperatorName(
           name, node.argumentsNode is Prefix);
     } else {
       dartMethodName = node.selector.asIdentifier().source;
     }
@@ skipping 48 matching lines @@
     inputs.add(closureTarget);
     addDynamicSendArgumentsToList(node, inputs);
     pushWithPosition(new HInvokeClosure(selector, inputs), node);
   }
 
   void handleForeignJs(Send node) {
     Link<Node> link = node.arguments;
     // If the invoke is on foreign code, don't visit the first
     // argument, which is the type, and the second argument,
     // which is the foreign code.
-    if (link.isEmpty() || link.tail.isEmpty()) {
+    if (link.isEmpty || link.tail.isEmpty) {
       compiler.cancel('At least two arguments expected',
                       node: node.argumentsNode);
     }
     List<HInstruction> inputs = <HInstruction>[];
     Node type = link.head;
     Node code = link.tail.head;
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     if (type is !LiteralString) {
       // The type must not be a juxtaposition or interpolation.
@@ skipping 10 matching lines @@
                           typeString.dartString,
                           inputs));
         return;
       }
     }
     compiler.cancel('JS code must be a string literal', node: code);
   }
 
   void handleForeignUnintercepted(Send node) {
     Link<Node> link = node.arguments;
-    if (!link.tail.isEmpty()) {
+    if (!link.tail.isEmpty) {
       compiler.cancel(
           'More than one expression in UNINTERCEPTED()', node: node);
     }
     Expression expression = link.head;
     disableMethodInterception();
     visit(expression);
     enableMethodInterception();
   }
 
   void handleForeignJsHasEquals(Send node) {
     List<HInstruction> inputs = <HInstruction>[];
-    if (!node.arguments.tail.isEmpty()) {
+    if (!node.arguments.tail.isEmpty) {
       compiler.cancel(
           'More than one expression in JS_HAS_EQUALS()', node: node);
     }
     addGenericSendArgumentsToList(node.arguments, inputs);
     String name = backend.namer.publicInstanceMethodNameByArity(
         Elements.OPERATOR_EQUALS, 1);
     push(new HForeign(new DartString.literal('!!#.$name'),
                       const LiteralDartString('bool'),
                       inputs));
   }
 
   void handleForeignJsCurrentIsolate(Send node) {
-    if (!node.arguments.isEmpty()) {
+    if (!node.arguments.isEmpty) {
       compiler.cancel(
           'Too many arguments to JS_CURRENT_ISOLATE', node: node);
     }
 
     if (!compiler.hasIsolateSupport()) {
       // If the isolate library is not used, we just generate code
       // to fetch the Leg's current isolate.
       String name = backend.namer.CURRENT_ISOLATE;
       push(new HForeign(new DartString.literal(name),
                         const LiteralDartString('var'),
@@ skipping 30 matching lines @@
       }
       HStatic target = new HStatic(element);
       add(target);
       List<HInstruction> inputs = <HInstruction>[target];
       addGenericSendArgumentsToList(link, inputs);
       push(new HInvokeStatic(inputs));
     }
   }
 
   void handleForeignDartClosureToJs(Send node) {
-    if (node.arguments.isEmpty() || !node.arguments.tail.isEmpty()) {
+    if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       compiler.cancel('Exactly one argument required',
                       node: node.argumentsNode);
     }
     Node closure = node.arguments.head;
     Element element = elements[closure];
     if (!Elements.isStaticOrTopLevelFunction(element)) {
       compiler.cancel(
           'JS_TO_CLOSURE requires a static or top-level method',
           node: closure);
     }
@@ skipping 150 matching lines @@
      *   Var             #                       [getRuntimeType(this).Var]
      *   C<int, D<Var>>  'C<int, D<' + # + '>>'  [getRuntimeType(this).Var]
      */
     void buildTypeString(DartType type, {isInQuotes: false}) {
       if (type is TypeVariableType) {
         addTypeVariableReference(type);
         template.add(isInQuotes ? "' + # +'" : "#");
       } else if (type is InterfaceType) {
         bool isFirstVariable = true;
         InterfaceType interfaceType = type;
-        bool hasTypeArguments = !interfaceType.arguments.isEmpty();
+        bool hasTypeArguments = !interfaceType.arguments.isEmpty;
         if (!isInQuotes) template.add("'");
         template.add(rti.getName(type.element));
         if (hasTypeArguments) {
           template.add("<");
           for (DartType argument in interfaceType.arguments) {
             if (!isFirstVariable) {
               template.add(", ");
             } else {
               isFirstVariable = false;
             }
@@ skipping 26 matching lines @@
     List<HInstruction> inputs = <HInstruction>[];
     type.arguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument, currentNode));
     });
     callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
   void callSetRuntimeTypeInfo(ClassElement element,
                               List<HInstruction> rtiInputs,
                               HInstruction newObject) {
-    bool needsRti = compiler.world.needsRti(element) && !rtiInputs.isEmpty();
+    bool needsRti = compiler.world.needsRti(element) && !rtiInputs.isEmpty;
     bool runtimeTypeIsUsed = compiler.enabledRuntimeType;
     if (!needsRti && !runtimeTypeIsUsed) return;
 
     HInstruction createForeign(String template,
                                List<HInstruction> arguments,
                                [String type = 'String']) {
       return new HForeign(new LiteralDartString(template),
                           new LiteralDartString(type),
                           arguments);
     }
@@ skipping 30 matching lines @@
     add(new HInvokeStatic(
         <HInstruction>[typeInfoSetter, newObject, runtimeInfo]));
   }
 
   visitNewSend(Send node) {
     bool isListConstructor = false;
     computeType(element) {
       Element originalElement = elements[node];
       if (identical(originalElement.getEnclosingClass(), compiler.listClass)) {
         isListConstructor = true;
-        if (node.arguments.isEmpty()) {
+        if (node.arguments.isEmpty) {
           return HType.EXTENDABLE_ARRAY;
         } else {
           return HType.MUTABLE_ARRAY;
         }
       } else if (element.isGenerativeConstructor()) {
         ClassElement cls = element.getEnclosingClass();
         return new HBoundedType.exact(cls.type);
       } else {
         return HType.UNKNOWN;
       }
@@ skipping 244 matching lines @@
           if (isPrefix) {
             stack.add(value);
           } else {
             stack.add(left);
           }
         }
       }
     } else if (const SourceString("=") == op.source) {
       Element element = elements[node];
       Link<Node> link = node.arguments;
-      assert(!link.isEmpty() && link.tail.isEmpty());
+      assert(!link.isEmpty && link.tail.isEmpty);
       visit(link.head);
       HInstruction value = pop();
       generateSetter(node, element, value);
     } else if (identical(op.source.stringValue, "is")) {
       compiler.internalError("is-operator as SendSet", node: op);
     } else {
       assert(const SourceString("++") == op.source ||
              const SourceString("--") == op.source ||
              node.assignmentOperator.source.stringValue.endsWith("="));
       Element element = elements[node];
-      bool isCompoundAssignment = !node.arguments.isEmpty();
+      bool isCompoundAssignment = !node.arguments.isEmpty;
       bool isPrefix = !node.isPostfix;  // Compound assignments are prefix.
 
       // [receiver] is only used if the node is an instance send.
       HInstruction receiver = null;
       if (Elements.isInstanceSend(node, elements)) {
         receiver = generateInstanceSendReceiver(node);
         generateInstanceGetterWithCompiledReceiver(node, receiver);
       } else {
         generateGetter(node, elements[node.selector]);
       }
@@ skipping 47 matching lines @@
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
   void visitLiteralNull(LiteralNull node) {
     stack.add(graph.addConstantNull(constantSystem));
   }
 
   visitNodeList(NodeList node) {
-    for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
+    for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       if (isAborted()) {
         compiler.reportWarning(link.head, 'dead code');
       } else {
         visit(link.head);
       }
     }
   }
 
   void visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
@@ skipping 24 matching lines @@
       compiler.internalError("Unimplemented: Redirecting factory constructor",
                              node: node);
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(constantSystem);
     } else {
       visit(node.expression);
       value = pop();
     }
-    if (!inliningStack.isEmpty()) {
+    if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
     } else {
       close(attachPosition(new HReturn(value), node)).addSuccessor(graph.exit);
     }
   }
 
   visitThrow(Throw node) {
     if (node.expression == null) {
       HInstruction exception = rethrowableException;
       if (exception == null) {
         exception = graph.addConstantNull(constantSystem);
         compiler.internalError(
             'rethrowableException should not be null', node: node);
       }
       close(new HThrow(exception, isRethrow: true));
     } else {
       visit(node.expression);
       close(new HThrow(pop()));
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     compiler.internalError('visiting type annotation in SSA builder',
                            node: node);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     for (Link<Node> link = node.definitions.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       Node definition = link.head;
       if (definition is Identifier) {
         HInstruction initialValue = graph.addConstantNull(constantSystem);
         localsHandler.updateLocal(elements[definition], initialValue);
       } else {
         assert(definition is SendSet);
         visitSendSet(definition);
         pop();  // Discard value.
       }
     }
   }
 
   visitLiteralList(LiteralList node) {
     if (node.isConst()) {
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
       stack.add(graph.addConstant(constant));
       return;
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.elements.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.add(pop());
     }
     push(new HLiteralList(inputs));
   }
 
   visitConditional(Conditional node) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(() => visit(node.condition),
@@ skipping 175 matching lines @@
 
   visitLiteralMap(LiteralMap node) {
     if (node.isConst()) {
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
       stack.add(graph.addConstant(constant));
       return;
     }
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.entries.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.addLast(pop());
       inputs.addLast(pop());
     }
     HLiteralList keyValuePairs = new HLiteralList(inputs);
     add(keyValuePairs);
     pushInvokeHelper1(interceptors.getMapMaker(), keyValuePairs);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     if (tryBuildConstantSwitch(node)) return;
 
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     HBasicBlock startBlock = openNewBlock();
     visit(node.expression);
     HInstruction expression = pop();
-    if (node.cases.isEmpty()) {
+    if (node.cases.isEmpty) {
       return;
     }
 
     Link<Node> cases = node.cases.nodes;
     JumpHandler jumpHandler = createJumpHandler(node);
 
     buildSwitchCases(cases, expression);
 
     HBasicBlock lastBlock = lastOpenedBlock;
 
@@ skipping 78 matching lines @@
     if (failure) {
       return false;
     }
 
     // TODO(ngeoffray): Handle switch-instruction in bailout code.
     work.allowSpeculativeOptimization = false;
     // Then build a switch structure.
     HBasicBlock expressionStart = openNewBlock();
     visit(node.expression);
     HInstruction expression = pop();
-    if (node.cases.isEmpty()) {
+    if (node.cases.isEmpty) {
       return true;
     }
     HBasicBlock expressionEnd = current;
 
     HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
     HBasicBlock expressionBlock = close(switchInstruction);
     JumpHandler jumpHandler = createJumpHandler(node);
     LocalsHandler savedLocals = localsHandler;
 
     List<List<Constant>> matchExpressions = <List<Constant>>[];
@@ skipping 145 matching lines @@
         compiler.reportWarning(node, 'Missing break at end of switch case');
         Element element =
             compiler.findHelper(const SourceString("getFallThroughError"));
         pushInvokeHelper0(element);
         HInstruction error = pop();
         close(new HThrow(error));
       }
     }
 
     Link<Node> skipLabels(Link<Node> labelsAndCases) {
-      while (!labelsAndCases.isEmpty() && labelsAndCases.head is Label) {
+      while (!labelsAndCases.isEmpty && labelsAndCases.head is Label) {
         labelsAndCases = labelsAndCases.tail;
       }
       return labelsAndCases;
     }
 
     Link<Node> labelsAndCases = skipLabels(node.labelsAndCases.nodes);
-    if (labelsAndCases.isEmpty()) {
+    if (labelsAndCases.isEmpty) {
       // Default case with no expressions.
       if (!node.isDefaultCase) {
         compiler.internalError("Case with no expression and not default",
                                node: node);
       }
       visit(node.statements);
       // This must be the final case (otherwise "default" would be invalid),
       // so we don't need to check for fallthrough.
       return;
     }
@@ skipping 15 matching lines @@
         if (constant != null) {
           stack.add(graph.addConstant(constant));
         } else {
           visit(match.expression);
         }
         push(new HEquals(target, pop(), expression));
       }
 
       // If this is the last expression, just return it.
       Link<Node> tail = skipLabels(remainingCases.tail);
-      if (tail.isEmpty()) {
+      if (tail.isEmpty) {
         left();
         return;
       }
 
       void right() {
         buildTests(tail);
       }
       SsaBranchBuilder branchBuilder =
           new SsaBranchBuilder(this, remainingCases.head);
       branchBuilder.handleLogicalAndOr(left, right, isAnd: false);
     }
 
     if (node.isDefaultCase) {
       // Default case must be last.
-      assert(cases.tail.isEmpty());
+      assert(cases.tail.isEmpty);
       // Perform the tests until one of them match, but then always execute the
       // statements.
       // TODO(lrn): Stop performing tests when all expressions are compile-time
       // constant strings or integers.
       handleIf(node, () { buildTests(labelsAndCases); }, (){}, null);
       visit(node.statements);
     } else {
-      if (cases.tail.isEmpty()) {
+      if (cases.tail.isEmpty) {
         handleIf(node,
                  () { buildTests(labelsAndCases); },
                  () { visit(node.statements); },
                  null);
       } else {
         handleIf(node,
                  () { buildTests(labelsAndCases); },
                  () { visitStatementsAndAbort(); },
                  () { buildSwitchCases(cases.tail, expression,
                                        encounteredCaseTypes); });
@@ skipping 30 matching lines @@
     HBasicBlock endFinallyBlock;
 
     startTryBlock = graph.addNewBlock();
     open(startTryBlock);
     visit(node.tryBlock);
     if (!isAborted()) endTryBlock = close(new HGoto());
     SubGraph bodyGraph = new SubGraph(startTryBlock, lastOpenedBlock);
     SubGraph catchGraph = null;
     HParameterValue exception = null;
 
-    if (!node.catchBlocks.isEmpty()) {
+    if (!node.catchBlocks.isEmpty) {
       localsHandler = new LocalsHandler.from(savedLocals);
       startCatchBlock = graph.addNewBlock();
       open(startCatchBlock);
       // Note that the name of this element is irrelevant.
       Element element = new Element(
           const SourceString('exception'), ElementKind.PARAMETER, work.element);
       exception = new HParameterValue(element);
       add(exception);
       HInstruction oldRethrowableException = rethrowableException;
       rethrowableException = exception;
@@ skipping 44 matching lines @@
         Node trace = catchBlock.trace;
         if (trace != null) {
           pushInvokeHelper1(interceptors.getTraceFromException(), exception);
           HInstruction traceInstruction = pop();
           localsHandler.updateLocal(elements[trace], traceInstruction);
         }
         visit(catchBlock);
       }
 
       void visitElse() {
-        if (link.isEmpty()) {
+        if (link.isEmpty) {
           close(new HThrow(exception, isRethrow: true));
         } else {
           CatchBlock newBlock = link.head;
           handleIf(node,
                    () { pushCondition(newBlock); },
                    visitThen, visitElse);
         }
       }
 
       CatchBlock firstBlock = link.head;
@@ skipping 414 matching lines @@
     //     }
     //     t3 = phi(t2, false);
     //   }
     //   result = phi(t3, false);
 
     Send send = left.asSend();
     if (send != null &&
         (isAnd ? send.isLogicalAnd : send.isLogicalOr)) {
       Node newLeft = send.receiver;
       Link<Node> link = send.argumentsNode.nodes;
-      assert(link.tail.isEmpty());
+      assert(link.tail.isEmpty);
       Node middle = link.head;
       handleLogicalAndOrWithLeftNode(
           newLeft,
           () => handleLogicalAndOrWithLeftNode(middle, visitRight,
                                                isAnd: isAnd),
           isAnd: isAnd);
     } else {
       handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd: isAnd);
     }
   }
@@ skipping 21 matching lines @@
       HPhi phi =
           new HPhi.manyInputs(null, <HInstruction>[thenValue, elseValue]);
       joinBranch.block.addPhi(phi);
       builder.stack.add(phi);
     }
 
     HBasicBlock thenBlock = thenBranch.block;
     HBasicBlock elseBlock = elseBranch.block;
     HBasicBlock joinBlock;
     // If at least one branch did not abort, open the joinBranch.
-    if (!joinBranch.block.predecessors.isEmpty()) {
+    if (!joinBranch.block.predecessors.isEmpty) {
       startBranch(joinBranch);
       joinBlock = joinBranch.block;
     }
 
     HIfBlockInformation info =
         new HIfBlockInformation(
           new HSubExpressionBlockInformation(conditionBranch.graph),
           new HSubGraphBlockInformation(thenBranch.graph),
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }