anchor.diff:        // TODO(lrn): Make sure to take continue into account.
         body();
       }
  -    handleIf(visitCondition, buildBody, null);
  +    handleIf(statement, visitCondition, buildBody, null);
     }
   }
   
  
positive.code:   }
  
    visitConditional(Conditional node) {
      HInstruction thenInstruction;
      HBasicBlock thenEndBlock;
      HInstruction elseInstruction;
      HBasicBlock elseEndBlock;
  
      void buildThen() {
        visit(node.thenExpression);
        if (isAborted()) {
          // Currently expressions cannot abort. Guard against future changes.
          compiler.internalError("aborted expression", node: node.thenExpression);
        }
        thenInstruction = pop();
        thenEndBlock = current;
      }
      void buildElse() {
        visit(node.elseExpression);
        if (isAborted()) {
          // Currently expressions cannot abort. Guard against future changes.
          compiler.internalError("aborted expression", node: node.elseExpression);
        }
        elseInstruction = pop();
        elseEndBlock = current;
      }
  
      handleIf(() => visit(node.condition), buildThen, buildElse);
  
      HBasicBlock joinBlock = current;
      if (joinBlock.predecessors.length != 2 ||
          joinBlock.predecessors[0] != thenEndBlock ||
          joinBlock.predecessors[1] != elseEndBlock) {
        // This is simply a sanity check that [handleIf] returns with the join
        // block set as [current]. In the current version of [handleIf] this is
        // always the case.
        compiler.internalError("handleIf not returning joinblock.",
                               node: node);
      }
      HPhi phi = new HPhi.manyInputs(null,
          <HInstruction>[thenInstruction, elseInstruction]);
      joinBlock.addPhi(phi);
      stack.add(phi);
    }
  
    visitStringInterpolation(StringInterpolation node) {
  
negative.code:       // 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()) {
          handleIf(node,
                   () { buildTests(labelsAndCases); },
                   () { visit(node.statements); },
                   null);
        } else {
          handleIf(node,
                   () { buildTests(labelsAndCases); },
                   () { visitStatementsAndAbort(); },
                   () { buildSwitchCases(cases.tail, expression,
                                         encounteredCaseTypes); });
  