code: protected void allocateThenInsertThenRehash(int slot, KType pendingKey, VType pendingValue) {
      assert assigned == resizeAt
             && Intrinsics.<KType> isEmpty(Intrinsics.<KType> cast(keys[slot]))
             && !Intrinsics.<KType> isEmpty(pendingKey);
  
      // Try to allocate new buffers first. If we OOM, we leave in a consistent state.
      final KType[] prevKeys = Intrinsics.<KType[]> cast(this.keys);
      final VType[] prevValues = Intrinsics.<VType[]> cast(this.values);
      allocateBuffers(nextBufferSize(mask + 1, size(), loadFactor));
      assert this.keys.length > prevKeys.length;
  
      // We have succeeded at allocating new data so insert the pending key/value at
      // the free slot in the old arrays before rehashing.
      prevKeys[slot] = pendingKey;
      prevValues[slot] = pendingValue;
  
      // Rehash old keys, including the pending key.
      rehash(prevKeys, prevValues);
    }
docs: This method is invoked when there is a new key/ value pair to be inserted into
  the buffers but there is not enough empty slots to do so.
  
  New buffers are allocated. If this succeeds, we know we can proceed
  with rehashing so we assign the pending element to the previous buffer
  (possibly violating the invariant of having at least one empty slot)
  and rehash all keys, substituting new buffers at the end.