anchor.diff:    }
   
     void visitLogicalAndOr(Send node, Operator op) {
  -    handleLogicalAndOr(node,
  -                       () { visit(node.receiver); },
  -                       () { visit(node.argumentsNode); },
  -                       isAnd: (const SourceString("&&") == op.source));
  -  }
  -
  -
  -  void handleLogicalAndOr(Node diagnosticNode,
  -                          void left(), void right(), [bool isAnd = true]) {
  -    // x && y is transformed into:
  -    //   t0 = boolify(x);
  -    //   if (t0) {
  -    //     t1 = boolify(y);
  -    //   } else {
  -    //     t2 = t0;
  -    //   }
  -    //   result = phi(t1, false);
  -    //
  -    // x || y is transformed into:
  -    //   t0 = boolify(x);
  -    //   if (not(t0)) {
  -    //     t1 = boolify(y);
  -    //   } else {
  -    //     t2 = t0;
  -    //   }
  -    //   result = phi(t1, true);
  -    HInstruction boolifiedLeft;
  -    HInstruction boolifiedRight;
  -
  -    void visitCondition() {
  -      left();
  -      boolifiedLeft = popBoolified();
  -      HInstruction condition;
  -      if (isAnd) {
  -        condition = boolifiedLeft;
  -      } else {
  -        condition = new HNot(boolifiedLeft);
  -        add(condition);
  -      }
  -      stack.add(condition);
  -    }
  -
  -    void visitThen() {
  -      right();
  -      boolifiedRight = popBoolified();
  -    }
  -
  -    handleIf(diagnosticNode, visitCondition, visitThen, null);
  -    HPhi result = new HPhi.manyInputs(null,
  -        <HInstruction>[boolifiedRight, graph.addConstantBool(!isAnd)]);
  -    current.addPhi(result);
  -    stack.add(result);
  -  }
  +    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
  +    branchBuilder.handleLogicalAndOr(
  +        () { visit(node.receiver); },
  +        () { visit(node.argumentsNode); },
  +        isAnd: (const SourceString("&&") == op.source));
  +  }
  +
   
     void visitLogicalNot(Send node) {
       assert(node.argumentsNode is Prefix);
  
positive.code:       void right() {
          buildTests(tail);
        }
        handleLogicalAndOr(remainingCases.head, left, right, isAnd: false);
      }
  
      if (node.isDefaultCase) {
  
negative.code:     _handleDiamondBranch(visitCondition, visitThen, visitElse, true);
    }
  
    void handleLogicalAndOr(void left(), void right(), [bool isAnd = true]) {
      // x && y is transformed into:
      //   t0 = boolify(x);
      //   if (t0) {
      //     t1 = boolify(y);
      //   } else {
      //     t2 = t0;
      //   }
      //   result = phi(t1, false);
      //
      // x || y is transformed into:
      //   t0 = boolify(x);
      //   if (not(t0)) {
      //     t1 = boolify(y);
      //   } else {
      //     t2 = t0;
      //   }
      //   result = phi(t1, true);
      HInstruction boolifiedLeft;
      HInstruction boolifiedRight;
  
      void visitCondition() {
        left();
        boolifiedLeft = builder.popBoolified();
        HInstruction condition;
        if (isAnd) {
          condition = boolifiedLeft;
        } else {
          condition = new HNot(boolifiedLeft);
          builder.add(condition);
        }
        builder.stack.add(condition);
      }
  
      void visitThen() {
        right();
        boolifiedRight = builder.popBoolified();
      }
  
      handleIf(visitCondition, visitThen, null);
      HPhi result = new HPhi.manyInputs(null,
          <HInstruction>[boolifiedRight, builder.graph.addConstantBool(!isAnd)]);
      builder.current.addPhi(result);
      builder.stack.add(result);
    }
  
    void _handleDiamondBranch(void visitCondition(),
                              void visitThen(),
                              void visitElse(),
  