anchor.diff:    /**
      * Merge [otherLocals] into this locals handler, creating phi-nodes when
      * there is a conflict.
  -   * If a phi node is necessary, it will use the otherLocals instruction as the
  -   * first input, and this handler's instruction as the second.
  -   * NOTICE: This means that the predecessor corresponding to [otherLocals]
  -   * should be the first predecessor of the current block, and the one
  -   * corresponding to this locals handler should be the second.
  +   * If a phi node is necessary, it will use this handler's instruction as the
  +   * first input, and the otherLocals instruction as the second.
      */
     void mergeWith(LocalsHandler otherLocals, HBasicBlock joinBlock) {
       // If an element is in one map but not the other we can safely
  
positive.code:           joinedLocals[element] = instruction;
          } else {
            HInstruction phi =
                new HPhi.manyInputs(element, <HInstruction>[instruction, mine]);
            joinBlock.addPhi(phi);
            joinedLocals[element] = phi;
          }
  
negative.code:       visitElse = () {};
      }
  
      _handleDiamondBranch(visitCondition, visitThen, visitElse, false);
    }
  
    handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
      assert(visitElse != null);
      _handleDiamondBranch(visitCondition, visitThen, visitElse, true);
    }
  
    void _handleDiamondBranch(void visitCondition(),
                              void visitThen(),
                              void visitElse(),
                              bool isExpression) {
      SsaBranch conditionBranch = new SsaBranch(this);
      SsaBranch thenBranch = new SsaBranch(this);
      SsaBranch elseBranch = new SsaBranch(this);
      SsaBranch joinBranch = new SsaBranch(this);
  
      conditionBranch.startLocals = builder.localsHandler;
      builder.goto(builder.current, conditionBranch.block);
  
      buildCondition(visitCondition, conditionBranch, thenBranch, elseBranch);
      HInstruction thenValue =
          buildBranch(thenBranch, visitThen, joinBranch, isExpression);
      HInstruction elseValue =
          buildBranch(elseBranch, visitElse, joinBranch, isExpression);
  
      if (isExpression) {
        assert(thenValue != null && elseValue != null);
        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()) {
        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;
  