anchor.diff:      branchBuilder.handleIf(visitCondition, visitThen, visitElse);
     }
   
  -  void visitLogicalAndOr(ast.Send node, ast.Operator op) {
  +  @override
  +  void visitLogicalAnd(ast.Send node, ast.Node left, ast.Node right, _) {
       SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
       branchBuilder.handleLogicalAndOrWithLeftNode(
  -        node.receiver,
  -        () { visit(node.argumentsNode); },
  -        isAnd: ("&&" == op.source));
  -  }
  -
  -  void visitLogicalNot(ast.Send node) {
  +        left,
  +        () { visit(right); },
  +        isAnd: true);
  +  }
  +
  +  @override
  +  void visitLogicalOr(ast.Send node, ast.Node left, ast.Node right, _) {
  +    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
  +    branchBuilder.handleLogicalAndOrWithLeftNode(
  +        left,
  +        () { visit(right); },
  +        isAnd: false);
  +  }
  +
  +  @override
  +  void visitNot(ast.Send node, ast.Node expression, _) {
       assert(node.argumentsNode is ast.Prefix);
  -    visit(node.receiver);
  +    visit(expression);
       HNot not = new HNot(popBoolified(), backend.boolType);
       pushWithPosition(not, node);
     }
   
  -  void visitUnarySend(ast.Send node, ast.Operator op) {
  +  @override
  +  void visitUnary(ast.Send node,
  +                  UnaryOperator operator,
  +                  ast.Node expression,_) {
       assert(node.argumentsNode is ast.Prefix);
  -    visit(node.receiver);
  -    assert(!identical(op.token.kind, PLUS_TOKEN));
  -    HInstruction operand = pop();
  +    HInstruction operand = visitAndPop(expression);
   
       // See if we can constant-fold right away. This avoids rewrites later on.
       if (operand is HConstant) {
  -      UnaryOperation operation = constantSystem.lookupUnary(
  -          UnaryOperator.parse(op.source));
  +      UnaryOperation operation = constantSystem.lookupUnary(operator);
         HConstant constant = operand;
         ConstantValue folded = operation.fold(constant.constant);
         if (folded != null) {
  
positive.code:   }
  
    visitOperatorSend(ast.Send node) {
      ast.Operator op = node.selector;
      if ("[]" == op.source) {
        visitDynamicSend(node);
      } else if ("&&" == op.source ||
                 "||" == op.source) {
        visitLogicalAndOr(node, op);
      } else if ("!" == op.source) {
        visitLogicalNot(node);
      } else if (node.argumentsNode is ast.Prefix) {
        visitUnarySend(node, op);
      } else if ("is" == op.source) {
        visitIsSend(node);
      } else if ("as" == op.source) {
        visit(node.receiver);
        HInstruction expression = pop();
        DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
        if (type.isMalformed) {
          ErroneousElement element = type.element;
          generateTypeError(node, element.message);
        } else {
          HInstruction converted = buildTypeConversion(
              expression,
              localsHandler.substInContext(type),
              HTypeConversion.CAST_TYPE_CHECK);
          if (converted != expression) add(converted);
          stack.add(converted);
        }
      } else {
        visit(node.receiver);
        visit(node.argumentsNode);
        var right = pop();
        var left = pop();
        visitBinarySend(left, op, right, elements.getSelector(node), node);
      }
    }
  
    void visitIsSend(ast.Send node) {
      visit(node.receiver);
      HInstruction expression = pop();
      bool isNot = node.isIsNotCheck;
      DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
      HInstruction instruction = buildIsNode(node, type, expression);
      if (isNot) {
        add(instruction);
        instruction = new HNot(instruction, backend.boolType);
      }
      push(instruction);
    }
  
    HInstruction buildIsNode(ast.Node node,
  
negative.code:       assert(arguments.tail.isEmpty);
        rhs = pop();
      }
      visitBinarySend(receiver, rhs,
                      elements.getOperatorSelectorInComplexSendSet(node),
                      node,
                      location: node.assignmentOperator);
    }
  
    @override
  