anchor.diff:      inputs.addAll(arguments);
       if (selector.isGetter()) {
         bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
  -      return new HInvokeDynamicGetter(selector, null, inputs, !hasGetter);
  +      pushWithPosition(
  +          new HInvokeDynamicGetter(selector, null, inputs, !hasGetter),
  +          location);
       } else if (selector.isSetter()) {
         bool hasSetter = compiler.world.hasAnyUserDefinedSetter(selector);
  -      return new HInvokeDynamicSetter(selector, null, inputs, !hasSetter);
  +      pushWithPosition(
  +          new HInvokeDynamicSetter(selector, null, inputs, !hasSetter),
  +          location);
       } else {
  -      return new HInvokeDynamicMethod(selector, inputs, isIntercepted);
  +      pushWithPosition(
  +          new HInvokeDynamicMethod(selector, inputs, isIntercepted),
  +          location);
       }
     }
   
  
positive.code:     inputs.add(receiver);
      addDynamicSendArgumentsToList(node, inputs);
  
      // We prefer to not inline certain operations on indexables,
      // because the constant folder will handle them better and turn
      // them into simpler instructions that allow further
      // optimizations.
      bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
        bool isLength = selector.isGetter()
            && selector.name == const SourceString("length");
        if (isLength || selector.isIndex()) {
          DartType classType = element.getEnclosingClass().computeType(compiler);
          HType type = new HType.nonNullExact(classType, compiler);
          return type.isIndexable(compiler);
        } else if (selector.isIndexSet()) {
          DartType classType = element.getEnclosingClass().computeType(compiler);
          HType type = new HType.nonNullExact(classType, compiler);
          return type.isMutableIndexable(compiler);
        } else {
          return false;
        }
      }
  
      Element element = compiler.world.locateSingleElement(selector);
      // TODO(ngeoffray): If [element] is a getter, then this send is
      // a closure send. We should teach that to [ResolvedVisitor].
      if (inline
          && element != null
          && !element.isGetter()
          // This check is to ensure we don't regress compared to our
          // previous limited inlining. We currently don't want to
          // inline methods on intercepted classes because the
          // optimizers apply their own optimizations on these methods.
          && (!backend.interceptedClasses.contains(element.getEnclosingClass())
              || isThisSend(node))
          // Avoid inlining optimizable operations on indexables.
          && !isOptimizableOperationOnIndexable(selector, element)) {
        if (tryInlineMethod(element, selector, node.arguments, inputs, node)) {
          return;
        }
      }
  
      HInstruction invoke = buildInvokeDynamic(node, selector, inputs);
      pushWithPosition(invoke, node);
    }
  
    visitClosureSend(Send node) {
  
negative.code:           index = pop();
          }
  
          pushInvokeDynamic(
              node,
              elements.getGetterSelectorInComplexSendSet(node),
              [receiver, index]);
          HInstruction getterInstruction = pop();
  
          handleComplexOperatorSend(node, getterInstruction, arguments);
          HInstruction value = pop();
  
          pushInvokeDynamic(
              node, elements.getSelector(node), [receiver, index, value]);
          pop();
  
          if (node.isPostfix) {
            stack.add(getterInstruction);
  