anchor.diff:          bool isNonEscapingUse(HInstruction use) {
             if (use is HReturn) return true; // Escapes, but so does control.
             if (use is HFieldGet) return true;
  -          if (use is HFieldSet &&
  -              use.receiver.nonCheck() == instruction &&
  -              use.value.nonCheck() != instruction) {
  -            return true;
  +          if (use is HFieldSet) {
  +            return use.value.nonCheck() != instruction;
             }
             if (use is HTypeInfoReadVariable) return true;
  +          if (use is HGetLength) return true;
  +          if (use is HBoundsCheck) return true;
  +          if (use is HIndex) return true;
  +          if (use is HIndexAssign) {
  +            return use.value.nonCheck() != instruction;
  +          }
  +          if (use is HInterceptor) return true;
  +          if (use is HInvokeDynamicMethod) {
  +            MemberEntity element = use.element;
  +            if (element != null) {
  +              if (element == closedWorld.commonElements.jsArrayAdd) {
  +                return use.inputs.last != instruction;
  +              }
  +            }
  +          }
  +          if (use is HInvokeStatic) {
  +            if (use.element ==
  +                closedWorld.commonElements.checkConcurrentModificationError)
  +              return true;
  +          }
  +
             return false;
           }
   
  
positive.code:       // Don't always create phis for HGetLength. The phi confuses array bounds
        // check elimination and the resulting variable-heavy code probably is
        // confusing for JavaScript VMs. In practice, this mostly affects the
        // expansion of for-in loops on Arrays, so we partially match the
        // expression
        //
        //     checkConcurrentModificationError(array.length == _end, array)
        //
        // starting with the HGetLength of the array.length.
        //
        // TODO(sra): Figure out a better way ensure 'nice' loop code.
        // TODO(22407): The phi would not be so bad if it did not confuse bounds
        // check elimination.
        // TODO(25437): We could add a phi if we undid the harmful cases.
        for (var user in second.usedBy) {
          if (user is HIdentity && user.usedBy.length == 1) {
            HInstruction user2 = user.usedBy.single;
            if (user2 is HInvokeStatic) {
              return null;
            }
          }
  
negative.code: 
    // Pure operations that do not escape their inputs.
    void visitBinaryArithmetic(HBinaryArithmetic instruction) {}
    void visitBoundsCheck(HBoundsCheck instruction) {}
    void visitConstant(HConstant instruction) {}
    void visitIf(HIf instruction) {}
    void visitInterceptor(HInterceptor instruction) {}
  