Check for collision only the leaf node

Author: Abduqodiri Qurbonzoda

core/commonMain/src/implementations/immutableMap/TrieNode.kt

@@ -76,7 +76,8 @@ internal class TrieNode<K, V>(
     internal var buffer: Array<Any?> = buffer
         private set
 
-    internal fun isCollision(): Boolean {
+    @Suppress("NOTHING_TO_INLINE")
+    internal inline fun isCollision(): Boolean {
         return dataMap == 0 && nodeMap == 0 && buffer.isNotEmpty()
     }
 
@@ -487,10 +488,6 @@ internal class TrieNode<K, V>(
     }
 
     fun containsKey(keyHash: Int, key: K, shift: Int): Boolean {
-        if (isCollision()) {
-            return collisionContainsKey(key)
-        }
-
         val keyPositionMask = 1 shl indexSegment(keyHash, shift)
 
         if (hasEntryAt(keyPositionMask)) { // key is directly in buffer
@@ -501,15 +498,15 @@ internal class TrieNode<K, V>(
             return targetNode.containsKey(keyHash, key, shift + LOG_MAX_BRANCHING_FACTOR)
         }
 
+        if (isCollision()) {
+            return collisionContainsKey(key)
+        }
+
         // key is absent
         return false
     }
 
     fun get(keyHash: Int, key: K, shift: Int): V? {
-        if (isCollision()) {
-            return collisionGet(key)
-        }
-
         val keyPositionMask = 1 shl indexSegment(keyHash, shift)
 
         if (hasEntryAt(keyPositionMask)) { // key is directly in buffer
@@ -525,15 +522,15 @@ internal class TrieNode<K, V>(
             return targetNode.get(keyHash, key, shift + LOG_MAX_BRANCHING_FACTOR)
         }
 
+        if (isCollision()) {
+            return collisionGet(key)
+        }
+
         // key is absent
         return null
     }
 
     fun put(keyHash: Int, key: K, value: @UnsafeVariance V, shift: Int): ModificationResult<K, V>? {
-        if (isCollision()) {
-            return collisionPut(key, value, shift)
-        }
-
         val keyPositionMask = 1 shl indexSegment(keyHash, shift)
 
         if (hasEntryAt(keyPositionMask)) { // key is directly in buffer
@@ -554,15 +551,15 @@ internal class TrieNode<K, V>(
             return putResult.replaceNode { node -> updateNodeAtIndex(nodeIndex, node) }
         }
 
+        if (isCollision()) {
+            return collisionPut(key, value, shift)
+        }
+
         // no entry at this key hash segment
         return insertEntryAt(keyPositionMask, key, value).asInsertResult()
     }
 
     fun mutablePut(keyHash: Int, key: K, value: @UnsafeVariance V, shift: Int, mutator: PersistentHashMapBuilder<K, V>): TrieNode<K, V> {
-        if (isCollision()) {
-            return mutableCollisionPut(key, value, shift, mutator)
-        }
-
         val keyPositionMask = 1 shl indexSegment(keyHash, shift)
 
         if (hasEntryAt(keyPositionMask)) { // key is directly in buffer
@@ -590,16 +587,16 @@ internal class TrieNode<K, V>(
             return mutableUpdateNodeAtIndex(nodeIndex, newNode, mutator.ownership)
         }
 
+        if (isCollision()) {
+            return mutableCollisionPut(key, value, shift, mutator)
+        }
+
         // key is absent
         mutator.size++
         return mutableInsertEntryAt(keyPositionMask, key, value, mutator.ownership)
     }
 
     fun remove(keyHash: Int, key: K, shift: Int): TrieNode<K, V>? {
-        if (isCollision()) {
-            return collisionRemove(key)
-        }
-
         val keyPositionMask = 1 shl indexSegment(keyHash, shift)
 
         if (hasEntryAt(keyPositionMask)) { // key is directly in buffer
@@ -622,15 +619,15 @@ internal class TrieNode<K, V>(
             }
         }
 
+        if (isCollision()) {
+            return collisionRemove(key)
+        }
+
         // key is absent
         return this
     }
 
     fun mutableRemove(keyHash: Int, key: K, shift: Int, mutator: PersistentHashMapBuilder<K, V>): TrieNode<K, V>? {
-        if (isCollision()) {
-            return mutableCollisionRemove(key, mutator)
-        }
-
         val keyPositionMask = 1 shl indexSegment(keyHash, shift)
 
         if (hasEntryAt(keyPositionMask)) { // key is directly in buffer
@@ -653,15 +650,15 @@ internal class TrieNode<K, V>(
             }
         }
 
+        if (isCollision()) {
+            return mutableCollisionRemove(key, mutator)
+        }
+
         // key is absent
         return this
     }
 
     fun remove(keyHash: Int, key: K, value: @UnsafeVariance V, shift: Int): TrieNode<K, V>? {
-        if (isCollision()) {
-            return collisionRemove(key, value)
-        }
-
         val keyPositionMask = 1 shl indexSegment(keyHash, shift)
 
         if (hasEntryAt(keyPositionMask)) { // key is directly in buffer
@@ -684,15 +681,15 @@ internal class TrieNode<K, V>(
             }
         }
 
+        if (isCollision()) {
+            return collisionRemove(key, value)
+        }
+
         // key is absent
         return this
     }
 
     fun mutableRemove(keyHash: Int, key: K, value: @UnsafeVariance V, shift: Int, mutator: PersistentHashMapBuilder<K, V>): TrieNode<K, V>? {
-        if (isCollision()) {
-            return mutableCollisionRemove(key, value, mutator)
-        }
-
         val keyPositionMask = 1 shl indexSegment(keyHash, shift)
 
         if (hasEntryAt(keyPositionMask)) { // key is directly in buffer
@@ -715,6 +712,10 @@ internal class TrieNode<K, V>(
             }
         }
 
+        if (isCollision()) {
+            return mutableCollisionRemove(key, value, mutator)
+        }
+
         // key is absent
         return this
     }

core/commonMain/src/implementations/immutableSet/TrieNode.kt

@@ -268,18 +268,18 @@ internal class TrieNode<E>(
         return makeCollisionNode(buffer.removeCellAtIndex(index), mutator.ownership)
     }
 
-    fun isCollision(): Boolean {
+    @Suppress("NOTHING_TO_INLINE")
+    inline fun isCollision(): Boolean {
         return bitmap == 0 && buffer.isNotEmpty()
     }
 
     fun contains(elementHash: Int, element: E, shift: Int): Boolean {
-        if (isCollision()) {
-            return collisionContains(elementHash, element)
-        }
-
         val cellPositionMask = 1 shl indexSegment(elementHash, shift)
 
         if (hasNoCellAt(cellPositionMask)) { // element is absent
+            if (isCollision()) {
+                return collisionContains(elementHash, element)
+            }
             return false
         }
 
@@ -293,13 +293,12 @@ internal class TrieNode<E>(
     }
 
     fun add(elementHash: Int, element: E, shift: Int): TrieNode<E> {
-        if (isCollision()) {
-            return collisionAdd(elementHash, element, shift)
-        }
-
         val cellPositionMask = 1 shl indexSegment(elementHash, shift)
 
         if (hasNoCellAt(cellPositionMask)) { // element is absent
+            if (isCollision()) {
+                return collisionAdd(elementHash, element, shift)
+            }
             return addElementAt(cellPositionMask, element)
         }
 
@@ -316,13 +315,12 @@ internal class TrieNode<E>(
     }
 
     fun mutableAdd(elementHash: Int, element: E, shift: Int, mutator: PersistentHashSetBuilder<*>): TrieNode<E> {
-        if (isCollision()) {
-            return collisionMutableAdd(elementHash, element, shift, mutator)
-        }
-
         val cellPosition = 1 shl indexSegment(elementHash, shift)
 
         if (hasNoCellAt(cellPosition)) { // element is absent
+            if (isCollision()) {
+                return collisionMutableAdd(elementHash, element, shift, mutator)
+            }
             mutator.size++
             return mutableAddElementAt(cellPosition, element, mutator.ownership)
         }
@@ -341,13 +339,12 @@ internal class TrieNode<E>(
     }
 
     fun remove(elementHash: Int, element: E, shift: Int): TrieNode<E>? {
-        if (isCollision()) {
-            return collisionRemove(elementHash, element)
-        }
-
         val cellPositionMask = 1 shl indexSegment(elementHash, shift)
 
         if (hasNoCellAt(cellPositionMask)) { // element is absent
+            if (isCollision()) {
+                return collisionRemove(elementHash, element)
+            }
             return this
         }
 
@@ -369,13 +366,12 @@ internal class TrieNode<E>(
     }
 
     fun mutableRemove(elementHash: Int, element: E, shift: Int, mutator: PersistentHashSetBuilder<*>): TrieNode<E>? {
-        if (isCollision()) {
-            return collisionMutableRemove(elementHash, element, mutator)
-        }
-
         val cellPositionMask = 1 shl indexSegment(elementHash, shift)
 
         if (hasNoCellAt(cellPositionMask)) { // element is absent
+            if (isCollision()) {
+                return collisionMutableRemove(elementHash, element, mutator)
+            }
             return this
         }