anchor.diff:      if (node != null) node.accept(this);
     }
   
  +  /// Visit [node] and pop the resulting [HInstruction].
  +  HInstruction visitAndPop(ast.Node node) {
  +    node.accept(this);
  +    return pop();
  +  }
  +
     visitBlock(ast.Block node) {
       assert(!isAborted());
       if (!isReachable) return;  // This can only happen when inlining.
  
positive.code:       assert(arguments.tail.isEmpty);
        rhs = pop();
      }
      visitBinarySend(receiver, node.assignmentOperator, rhs,
                      elements.getOperatorSelectorInComplexSendSet(node), node);
    }
  
    @override
  
negative.code:   }
  
    visitOperatorSend(ast.Send node) {
      internalError(node, 'Unexpected operator send: ${node}');
    }
  
    @override
    void visitAs(ast.Send node, ast.Node expression, DartType type, _) {
      HInstruction expressionInstruction = visitAndPop(expression);
      if (type.isMalformed) {
        ErroneousElement element = type.element;
        generateTypeError(node, element.message);
      } else {
        HInstruction converted = buildTypeConversion(
            expressionInstruction,
            localsHandler.substInContext(type),
            HTypeConversion.CAST_TYPE_CHECK);
        if (converted != expressionInstruction) add(converted);
        stack.add(converted);
      }
    }
  
    @override
    void visitIs(ast.Send node, ast.Node expression, DartType type, _) {
      HInstruction expressionInstruction = visitAndPop(expression);
      push(buildIsNode(node, type, expressionInstruction));
    }
  
    @override
    void visitIsNot(ast.Send node, ast.Node expression, DartType type, _) {
      HInstruction expressionInstruction = visitAndPop(expression);
      HInstruction instruction = buildIsNode(node, type, expressionInstruction);
      add(instruction);
      push(new HNot(instruction, backend.boolType));
    }
  
    HInstruction buildIsNode(ast.Node node,
  