anchor.diff:        assert(arguments.tail.isEmpty);
         rhs = pop();
       }
  -    visitBinarySend(receiver, node.assignmentOperator, rhs,
  -                    elements.getOperatorSelectorInComplexSendSet(node), node);
  +    visitBinarySend(receiver, rhs,
  +                    elements.getOperatorSelectorInComplexSendSet(node),
  +                    node,
  +                    location: node.assignmentOperator);
     }
   
     @override
  
positive.code:     branchBuilder.handleIf(visitCondition, visitThen, visitElse);
    }
  
    void visitLogicalAndOr(ast.Send node, ast.Operator op) {
      SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
      branchBuilder.handleLogicalAndOrWithLeftNode(
          node.receiver,
          () { visit(node.argumentsNode); },
          isAnd: ("&&" == op.source));
    }
  
    void visitLogicalNot(ast.Send node) {
      assert(node.argumentsNode is ast.Prefix);
      visit(node.receiver);
      HNot not = new HNot(popBoolified(), backend.boolType);
      pushWithPosition(not, node);
    }
  
    void visitUnarySend(ast.Send node, ast.Operator op) {
      assert(node.argumentsNode is ast.Prefix);
      visit(node.receiver);
      assert(!identical(op.token.kind, PLUS_TOKEN));
      HInstruction operand = pop();
  
      // 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));
        HConstant constant = operand;
        ConstantValue folded = operation.fold(constant.constant);
        if (folded != null) {
  
negative.code:     pushInvokeDynamic(node, elements.getSelector(node), [operand]);
    }
  
    @override
    void visitBinary(ast.Send node,
                     ast.Node left,
                     BinaryOperator operator,
                     ast.Node right, _) {
      handleBinary(node, left, right);
    }
  
    @override
    void visitIndex(ast.Send node, ast.Node receiver, ast.Node index, _) {
      // TODO(johnniwinther): Add a new helper to join the paths used by
      // [visitIndex], [visitDynamicSend] and [handleSendSet].
      visitDynamicSend(node);
    }
  
    @override
    void visitEquals(ast.Send node, ast.Node left, ast.Node right, _) {
      handleBinary(node, left, right);
    }
  
    @override
    void visitNotEquals(ast.Send node, ast.Node left, ast.Node right, _) {
      handleBinary(node, left, right);
      pushWithPosition(new HNot(popBoolified(), backend.boolType), node.selector);
    }
  
    void handleBinary(ast.Send node, ast.Node left, ast.Node right) {
      visitBinarySend(
          visitAndPop(left),
          visitAndPop(right),
          elements.getSelector(node),
          node,
          location: node.selector);
    }
  
    /// TODO(johnniwinther): Merge [visitBinarySend] with [handleBinary] and
    /// remove use of [location] for source information.
    void visitBinarySend(HInstruction left,
                         HInstruction right,
                         Selector selector,
                         ast.Send send,
                         {ast.Node location}) {
      pushInvokeDynamic(send, selector, [left, right], location: location);
    }
  
    HInstruction generateInstanceSendReceiver(ast.Send send) {
  