anchor.diff:  
     // 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) {}
  
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:         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) {
              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;
          }
  
  