converted assertion to InternalError check and applied some intellij cleanups

Author: dougxc

sdk/src/org.graalvm.collections/src/org/graalvm/collections/EconomicMapImpl.java

@@ -48,23 +48,23 @@
  * Implementation of a map with a memory-efficient structure that always preserves insertion order
  * when iterating over keys. Particularly efficient when number of entries is 0 or smaller equal
  * {@link #INITIAL_CAPACITY} or smaller 256.
- *
+ * <p>
  * The key/value pairs are kept in an expanding flat object array with keys at even indices and
  * values at odd indices. If the map has smaller or equal to {@link #HASH_THRESHOLD} entries, there
  * is no additional hash data structure and comparisons are done via linear checking of the
  * key/value pairs. For the case where the equality check is particularly cheap (e.g., just an
  * object identity comparison), this limit below which the map is without an actual hash table is
  * higher and configured at {@link #HASH_THRESHOLD_IDENTITY_COMPARE}.
- *
+ * <p>
  * When the hash table needs to be constructed, the field {@link #hashArray} becomes a new hash
  * array where an entry of 0 means no hit and otherwise denotes the entry number in the
  * {@link #entries} array. The hash array is interpreted as an actual byte array if the indices fit
  * within 8 bit, or as an array of short values if the indices fit within 16 bit, or as an array of
  * integer values in other cases.
- *
+ * <p>
  * Hash collisions are handled by chaining a linked list of {@link CollisionLink} objects that take
  * the place of the values in the {@link #entries} array.
- *
+ * <p>
  * Removing entries will put {@code null} into the {@link #entries} array. If the occupation of the
  * map falls below a specific threshold, the map will be compressed via the
  * {@link #maybeCompress(int)} method.
@@ -355,8 +355,7 @@ private int findAndRemoveHash(Object key) {
             if (compareKeys(key, entryKey)) {
                 Object value = getRawValue(index);
                 int nextIndex = -1;
-                if (value instanceof CollisionLink) {
-                    CollisionLink collisionLink = (CollisionLink) value;
+                if (value instanceof CollisionLink collisionLink) {
                     nextIndex = collisionLink.next;
                 }
                 setHashArray(hashIndex, nextIndex + 1);
@@ -383,8 +382,7 @@ private int findAndRemoveWithCollision(Object key, CollisionLink initialEntryVal
             entryKey = getKey(index);
             if (compareKeys(key, entryKey)) {
                 Object value = getRawValue(index);
-                if (value instanceof CollisionLink) {
-                    CollisionLink thisCollisionLink = (CollisionLink) value;
+                if (value instanceof CollisionLink thisCollisionLink) {
                     setRawValue(lastIndex, new CollisionLink(collisionLink.value, thisCollisionLink.next));
                 } else {
                     setRawValue(lastIndex, collisionLink.value);
@@ -581,16 +579,16 @@ private void putHashEntry(Object key, int entryIndex, boolean rehashOnCollision)
         setHashArray(hashIndex, entryIndex + 1);
         Object value = getRawValue(entryIndex);
         if (oldIndex != -1) {
-            assert entryIndex != oldIndex : "this cannot happen and would create an endless collision link cycle";
-            if (value instanceof CollisionLink) {
-                CollisionLink collisionLink = (CollisionLink) value;
+            if (entryIndex == oldIndex) {
+                throw new InternalError("endless collision link cycle, most likely due to unsynchronized concurrent access");
+            }
+            if (value instanceof CollisionLink collisionLink) {
                 setRawValue(entryIndex, new CollisionLink(collisionLink.value, oldIndex));
             } else {
                 setRawValue(entryIndex, new CollisionLink(getRawValue(entryIndex), oldIndex));
             }
         } else {
-            if (value instanceof CollisionLink) {
-                CollisionLink collisionLink = (CollisionLink) value;
+            if (value instanceof CollisionLink collisionLink) {
                 setRawValue(entryIndex, collisionLink.value);
             }
         }
@@ -700,6 +698,7 @@ public void remove() {
         }
     }
 
+    @SuppressWarnings({"rawtypes", "unchecked"})
     @Override
     public Iterable<V> getValues() {
         return new Iterable<>() {
@@ -811,8 +810,7 @@ private void setKey(int index, Object newValue) {
 
     private void setValue(int index, Object newValue) {
         Object oldValue = getRawValue(index);
-        if (oldValue instanceof CollisionLink) {
-            CollisionLink collisionLink = (CollisionLink) oldValue;
+        if (oldValue instanceof CollisionLink collisionLink) {
             setRawValue(index, new CollisionLink(newValue, collisionLink.next));
         } else {
             setRawValue(index, newValue);
@@ -859,6 +857,7 @@ static <K, V> String toString(boolean isSet, int size, MapCursor<K, V> cursor) {
         return builder.toString();
     }
 
+    @SuppressWarnings({"rawtypes", "unchecked"})
     @Override
     public Iterator<K> iterator() {
         return new SparseMapIterator<>() {