anchor.diff:      } else if (name == 'JS_BUILTIN') {
         handleForeignJsBuiltin(node);
       } else if (name == 'JS_GET_FLAG') {
  -      handleForeingJsGetFlag(node);
  +      handleForeignJsGetFlag(node);
       } else if (name == 'JS_EFFECT') {
         stack.add(graph.addConstantNull(compiler));
       } else if (name == 'JS_INTERCEPTOR_CONSTANT') {
  
positive.code:                     location: node.assignmentOperator);
    }
  
    @override
    handleSendSet(ast.SendSet node) {
      generateIsDeferredLoadedCheckOfSend(node);
      Element element = elements[node];
      if (!Elements.isUnresolved(element) && element.impliesType) {
        ast.Identifier selector = node.selector;
        generateThrowNoSuchMethod(node, selector.source,
                                  argumentNodes: node.arguments);
        return;
      }
      ast.Operator op = node.assignmentOperator;
      if (node.isSuperCall) {
        List<HInstruction> setterInputs = <HInstruction>[];
        void generateSuperSendSet() {
          Selector setterSelector = elements.getSelector(node);
          if (Elements.isUnresolved(element)
              || !setterSelector.applies(element, compiler.world)) {
            generateSuperNoSuchMethodSend(
                node, setterSelector, setterInputs);
            pop();
          } else {
            add(buildInvokeSuper(setterSelector, element, setterInputs));
          }
        }
        if (identical(node.assignmentOperator.source, '=')) {
          addDynamicSendArgumentsToList(node, setterInputs);
          generateSuperSendSet();
          stack.add(setterInputs.last);
        } else {
          Element getter = elements[node.selector];
          List<HInstruction> getterInputs = <HInstruction>[];
          Link<ast.Node> arguments = node.arguments;
          if (node.isIndex) {
            // If node is of the from [:super.foo[0] += 2:], the send has
            // two arguments: the index and the left hand side. We get
            // the index and add it as input of the getter and the
            // setter.
            visit(arguments.head);
            arguments = arguments.tail;
            HInstruction index = pop();
            getterInputs.add(index);
            setterInputs.add(index);
          }
          HInstruction getterInstruction;
          Selector getterSelector =
              elements.getGetterSelectorInComplexSendSet(node);
          if (Elements.isUnresolved(getter)) {
            generateSuperNoSuchMethodSend(
                node,
                getterSelector,
                getterInputs);
            getterInstruction = pop();
          } else {
            getterInstruction = buildInvokeSuper(
                getterSelector, getter, getterInputs);
            add(getterInstruction);
          }
  
          if (node.isIfNullAssignment) {
            SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
            brancher.handleIfNull(() => stack.add(getterInstruction),
                () {
                  addDynamicSendArgumentsToList(node, setterInputs);
                  generateSuperSendSet();
                  stack.add(setterInputs.last);
                });
          } else {
            handleComplexOperatorSend(node, getterInstruction, arguments);
            setterInputs.add(pop());
            generateSuperSendSet();
            stack.add(node.isPostfix ? getterInstruction : setterInputs.last);
          }
        }
      } else if (node.isIndex) {
        if ("=" == op.source) {
          generateDynamicSend(node);
        } else {
          visit(node.receiver);
          HInstruction receiver = pop();
          Link<ast.Node> arguments = node.arguments;
          HInstruction index;
          if (node.isIndex) {
            visit(arguments.head);
            arguments = arguments.tail;
            index = pop();
          }
  
          pushInvokeDynamic(
              node,
              elements.getGetterSelectorInComplexSendSet(node),
              [receiver, index]);
          HInstruction getterInstruction = pop();
          if (node.isIfNullAssignment) {
            // Compile x[i] ??= e as:
            //   t1 = x[i]
            //   if (t1 == null)
            //      t1 = x[i] = e;
            //   result = t1
            SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
            brancher.handleIfNull(() => stack.add(getterInstruction),
                () {
                  visit(arguments.head);
                  HInstruction value = pop();
                  pushInvokeDynamic(
                      node, elements.getSelector(node), [receiver, index, value]);
                  pop();
                  stack.add(value);
                });
          } else {
            handleComplexOperatorSend(node, getterInstruction, arguments);
            HInstruction value = pop();
            pushInvokeDynamic(
                node, elements.getSelector(node), [receiver, index, value]);
            pop();
            if (node.isPostfix) {
              stack.add(getterInstruction);
            } else {
              stack.add(value);
            }
          }
        }
      } else if ("=" == op.source) {
        Link<ast.Node> link = node.arguments;
        assert(!link.isEmpty && link.tail.isEmpty);
        if (Elements.isInstanceSend(node, elements)) {
          generatePossiblyConditionalInstanceSetter(node,
              () => generateInstanceSendReceiver(node),
              () => visitAndPop(link.head));
        } else {
          visit(link.head);
          generateNonInstanceSetter(node, element, pop());
        }
      } else if (identical(op.source, "is")) {
        compiler.internalError(op, "is-operator as SendSet.");
      } else {
        assert("++" == op.source || "--" == op.source ||
               node.assignmentOperator.source.endsWith("="));
  
        Element getter = elements[node.selector];
  
        if (!Elements.isUnresolved(getter) && getter.impliesType) {
          if (node.isIfNullAssignment) {
            // C ??= x is compiled just as C.
            stack.add(addConstant(node.selector));
          } else {
            ast.Identifier selector = node.selector;
            generateThrowNoSuchMethod(node, selector.source,
                                      argumentNodes: node.arguments);
          }
          return;
        }
  
        if (Elements.isInstanceSend(node, elements)) {
          void generateAssignment(HInstruction receiver) {
            // desugars `e.x op= e2` to `e.x = e.x op e2`
            generateInstanceGetterWithCompiledReceiver(
                node, elements.getGetterSelectorInComplexSendSet(node), receiver);
            HInstruction getterInstruction = pop();
            if (node.isIfNullAssignment) {
              SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
              brancher.handleIfNull(() => stack.add(getterInstruction),
                  () {
                    visit(node.arguments.head);
                    generateInstanceSetterWithCompiledReceiver(
                        node, receiver, pop());
                  });
            } else {
              handleComplexOperatorSend(node, getterInstruction, node.arguments);
              HInstruction value = pop();
              generateInstanceSetterWithCompiledReceiver(node, receiver, value);
            }
            if (node.isPostfix) {
              pop();
              stack.add(getterInstruction);
            }
          }
          if (node.isConditional) {
            // generate `e?.x op= e2` as:
            //   t1 = e
            //   t1 == null ? t1 : (t1.x = t1.x op e2);
            HInstruction receiver;
            SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
            brancher.handleConditional(
                () {
                  receiver = generateInstanceSendReceiver(node);
                  pushCheckNull(receiver);
                },
                () => stack.add(receiver),
                () => generateAssignment(receiver));
          } else {
            generateAssignment(generateInstanceSendReceiver(node));
          }
          return;
        }
  
        if (getter.isErroneous) {
          generateStaticUnresolvedGet(node, getter);
        } else if (getter.isField) {
          generateStaticFieldGet(node, getter);
        } else if (getter.isGetter) {
          generateStaticGetterGet(node, getter);
        } else if (getter.isFunction) {
          generateStaticFunctionGet(node, getter);
        } else if (getter.isLocal) {
          handleLocalGet(getter);
        } else {
          internalError(node, "Unexpected getter: $getter");
        }
        HInstruction getterInstruction = pop();
        if (node.isIfNullAssignment) {
          SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
          brancher.handleIfNull(() => stack.add(getterInstruction),
              () {
                visit(node.arguments.head);
                generateNonInstanceSetter(node, element, pop());
              });
        } else {
          handleComplexOperatorSend(node, getterInstruction, node.arguments);
          HInstruction value = pop();
          generateNonInstanceSetter(node, element, value);
        }
        if (node.isPostfix) {
          pop();
          stack.add(getterInstruction);
        }
      }
    }
  
  
negative.code:     generateStaticGetterGet(node, getter);
    }
  
    void generateInstanceSetterWithCompiledReceiver(ast.Send send,
                                                    HInstruction receiver,
                                                    HInstruction value,
  