[JS IR] Fix review comments.

libraries/stdlib/js/src/kotlin/collections/HashMapEntry.kt

@@ -68,7 +68,6 @@ internal abstract class HashMapEntrySetBase<K, V, E : Map.Entry<K, V>> internal
     override val size: Int get() = backing.size
     override fun isEmpty(): Boolean = backing.size == 0
     override fun contains(element: E): Boolean = backing.containsEntry(element)
-    protected abstract fun getEntry(element: Map.Entry<K, V>): E?
     override fun clear() = backing.clear()
     override fun add(element: E): Boolean = throw UnsupportedOperationException()
     override fun addAll(elements: Collection<E>): Boolean = throw UnsupportedOperationException()
@@ -85,8 +84,5 @@ internal abstract class HashMapEntrySetBase<K, V, E : Map.Entry<K, V>> internal
 internal class HashMapEntrySet<K, V> internal constructor(
     backing: InternalMap<K, V>,
 ) : HashMapEntrySetBase<K, V, MutableMap.MutableEntry<K, V>>(backing) {
-
-    override fun getEntry(element: Map.Entry<K, V>): MutableMap.MutableEntry<K, V>? = backing.getEntry(element)
-
     override fun iterator(): MutableIterator<MutableMap.MutableEntry<K, V>> = backing.entriesIterator()
 }

libraries/stdlib/js/src/kotlin/collections/InternalHashMap.kt

@@ -425,15 +425,6 @@ internal class InternalHashMap<K, V> private constructor(
         return containsEntry(entry as Map.Entry<K, V>)
     }
 
-    override fun getEntry(entry: Map.Entry<K, V>): MutableMap.MutableEntry<K, V>? {
-        val index = findKey(entry.key)
-        return if (index < 0 || valuesArray!![index] != entry.value) {
-            null
-        } else {
-            EntryRef(this, index)
-        }
-    }
-
     private fun contentEquals(other: Map<*, *>): Boolean = _size == other.size && containsAllEntries(other.entries)
 
     private fun putEntry(entry: Map.Entry<K, V>): Boolean {

libraries/stdlib/js/src/kotlin/collections/InternalMap.kt

@@ -15,7 +15,6 @@ internal interface InternalMap<K, V> {
     fun putAll(from: Map<out K, V>)
 
     operator fun get(key: K): V?
-    fun getEntry(entry: Map.Entry<K, V>): MutableMap.MutableEntry<K, V>?
 
     operator fun contains(key: K): Boolean
     fun containsValue(value: V): Boolean

libraries/stdlib/js/src/kotlin/collections/InternalStringLinkedMap.kt

@@ -60,6 +60,12 @@ internal class InternalStringLinkedMap<K, V> : InternalStringMap<K, V>() {
         return prevValue
     }
 
+    private fun IntArray.updateIndexAt(indexReference: Int, newIndex: Int) {
+        if (indexReference >= 0) {
+            this[indexReference] = newIndex
+        }
+    }
+
     override fun removeKeyIndex(key: K, removingIndex: Int) {
         super.removeKeyIndex(key, removingIndex)
 
@@ -67,8 +73,8 @@ internal class InternalStringLinkedMap<K, V> : InternalStringMap<K, V>() {
         val nextIndex = nextIndexes[removingIndex]
         val prevIndex = prevIndexes[removingIndex]
 
-        nextIndexes[prevIndex] = nextIndex
+        nextIndexes.updateIndexAt(prevIndex, nextIndex)
-        prevIndexes[nextIndex] = prevIndex
+        prevIndexes.updateIndexAt(nextIndex, prevIndex)
 
         if (headIndex == removingIndex) {
             headIndex = nextIndex
@@ -82,8 +88,8 @@ internal class InternalStringLinkedMap<K, V> : InternalStringMap<K, V>() {
         if (removingIndex != lastIndex) {
             nextIndexes[removingIndex] = nextIndexes[lastIndex]
             prevIndexes[removingIndex] = prevIndexes[lastIndex]
-            nextIndexes[prevIndexes[removingIndex]] = removingIndex
+            nextIndexes.updateIndexAt(prevIndexes[removingIndex], removingIndex)
-            prevIndexes[nextIndexes[removingIndex]] = removingIndex
+            prevIndexes.updateIndexAt(nextIndexes[removingIndex], removingIndex)
             if (headIndex == lastIndex) {
                 headIndex = removingIndex
             }

libraries/stdlib/js/src/kotlin/collections/InternalStringMap.kt

@@ -96,28 +96,19 @@ internal open class InternalStringMap<K, V> : InternalMap<K, V> {
     override val size: Int
         get() = keys.length
 
+    private fun findKeyIndex(key: K): Int? {
+        if (key !is String) return null
+        val index = backingMap[key]
+        return if (index !== undefined) index.unsafeCast<Int>() else null
+    }
+
     override operator fun contains(key: K): Boolean {
-        if (key !is String) return false
+        return findKeyIndex(key) != null
-        return backingMap[key] !== undefined
     }
 
     override operator fun get(key: K): V? {
-        if (key !is String) return null
+        val index = findKeyIndex(key) ?: return null
-        val index = backingMap[key]
+        return values.getElement(index)
-        return if (index !== undefined) values.getElement(index.unsafeCast<Int>()) else null
-    }
-
-    override fun getEntry(entry: Map.Entry<K, V>): MutableEntry<K, V>? {
-        val key = entry.key as? String ?: return null
-        val index = backingMap[key]
-        if (index === undefined) {
-            return null
-        }
-        val value = values.getElement(index.unsafeCast<Int>())
-        if (value == entry.value) {
-            return EntryRef(entry.key, value, this)
-        }
-        return null
     }
 
     override fun containsValue(value: V): Boolean {
@@ -125,7 +116,8 @@ internal open class InternalStringMap<K, V> : InternalMap<K, V> {
     }
 
     override fun containsEntry(entry: Map.Entry<K, V>): Boolean {
-        return getEntry(entry) != null
+        val index = findKeyIndex(entry.key) ?: return false
+        return values.getElement(index) == entry.value
     }
 
     override fun containsOtherEntry(entry: Map.Entry<*, *>): Boolean {
@@ -134,8 +126,12 @@ internal open class InternalStringMap<K, V> : InternalMap<K, V> {
     }
 
     override fun removeEntry(entry: Map.Entry<K, V>): Boolean {
-        val key = getEntry(entry)?.key ?: return false
+        val index = findKeyIndex(entry.key) ?: return false
-        return remove(key) != null
+        if (values.getElement(index) == entry.value) {
+            removeKeyIndex(keys.getElement(index), index)
+            return true
+        }
+        return false
     }
 
     override fun removeValue(value: V): Boolean {
@@ -171,17 +167,10 @@ internal open class InternalStringMap<K, V> : InternalMap<K, V> {
     }
 
     override fun remove(key: K): V? {
-        if (key !is String) return null
+        val index = findKeyIndex(key) ?: return null
-        val index = backingMap[key]
+        val removingValue = values.getElement(index)
-        if (index === undefined) {
+        removeKeyIndex(key, index)
-            return null
+        return removingValue
-        }
-
-        val i = index.unsafeCast<Int>()
-        val removedValue = values.getElement(i)
-
-        removeKeyIndex(key, i)
-        return removedValue
     }
 
     internal open fun removeKeyIndex(key: K, removingIndex: Int) {