Use Any?.hashCode extension from Kotlin 1.3

ilya-g · ilya-g · commit e0a257b66621 · 2019-03-28T19:43:06.000+03:00
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMap.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMap.kt
@@ -53,35 +53,30 @@ internal class PersistentHashMap<K, V>(internal val node: TrieNode<K, V>,
     }
 
     override fun containsKey(key: K): Boolean {
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        return node.containsKey(keyHash, key, 0)
+        return node.containsKey(key.hashCode(), key, 0)
     }
 
     override fun get(key: K): V? {
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        return node.get(keyHash, key, 0)
+        return node.get(key.hashCode(), key, 0)
     }
 
     override fun put(key: K, value: @UnsafeVariance V): PersistentHashMap<K, V> {
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
         val modification = ModificationWrapper()
-        val newNode = node.put(keyHash, key, value, 0, modification)
+        val newNode = node.put(key.hashCode(), key, value, 0, modification)
         if (node === newNode) { return this }
         val sizeDelta = if (modification.value == PUT_KEY_VALUE) 1 else 0
         return PersistentHashMap(newNode, size + sizeDelta)
     }
 
     override fun remove(key: K): PersistentHashMap<K, V> {
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        val newNode = node.remove(keyHash, key, 0)
+        val newNode = node.remove(key.hashCode(), key, 0)
         if (node === newNode) { return this }
         if (newNode == null) { return PersistentHashMap.emptyOf() }
         return PersistentHashMap(newNode, size - 1)
     }
 
     override fun remove(key: K, value: @UnsafeVariance V): PersistentHashMap<K, V> {
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        val newNode = node.remove(keyHash, key, value, 0)
+        val newNode = node.remove(key.hashCode(), key, value, 0)
         if (node === newNode) { return this }
         if (newNode == null) { return PersistentHashMap.emptyOf() }
         return PersistentHashMap(newNode, size - 1)
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapBuilder.kt
@@ -52,33 +52,28 @@ internal class PersistentHashMapBuilder<K, V>(private var map: PersistentHashMap
         }
 
     override fun containsKey(key: K): Boolean {
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        return node.containsKey(keyHash, key, 0)
+        return node.containsKey(key.hashCode(), key, 0)
     }
 
     override fun get(key: K): V? {
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        return node.get(keyHash, key, 0)
+        return node.get(key.hashCode(), key, 0)
     }
 
     override fun put(key: K, value: @UnsafeVariance V): V? {
         operationResult = null
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        node = node.mutablePut(keyHash, key, value, 0, this)
+        node = node.mutablePut(key.hashCode(), key, value, 0, this)
         return operationResult
     }
 
     override fun remove(key: K): V? {
         operationResult = null
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        node = node.mutableRemove(keyHash, key, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>
+        node = node.mutableRemove(key.hashCode(), key, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>
         return operationResult
     }
 
     fun remove(key: K, value: V): Boolean {
         val oldSize = size
-        val keyHash = key?.hashCode() ?: NULL_HASH_CODE
-        node = node.mutableRemove(keyHash, key, value, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>
+        node = node.mutableRemove(key.hashCode(), key, value, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>
         return oldSize != size
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapBuilderContentIterators.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapBuilderContentIterators.kt
@@ -60,7 +60,7 @@ internal abstract class PersistentHashMapBuilderBaseIterator<K, V, T>(private va
             val currentKey = currentKey()
 
             builder.remove(lastKey)
-            resetPath(currentKey?.hashCode() ?: NULL_HASH_CODE, builder.node, currentKey, 0)
+            resetPath(currentKey.hashCode(), builder.node, currentKey, 0)
         } else {
             builder.remove(lastKey)
         }
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/TrieNode.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/TrieNode.kt
@@ -6,7 +6,6 @@ internal const val LOG_MAX_BRANCHING_FACTOR = 5
 internal const val MAX_BRANCHING_FACTOR_MINUS_ONE = MAX_BRANCHING_FACTOR - 1
 internal const val ENTRY_SIZE = 2
 internal const val MAX_SHIFT = 30
-internal const val NULL_HASH_CODE = 0
 
 
 internal class TrieNode<K, V>(var dataMap: Int,
@@ -116,7 +115,7 @@ internal class TrieNode<K, V>(var dataMap: Int,
     private fun bufferMoveDataToNode(keyIndex: Int, position: Int, newKeyHash: Int,
                                      newKey: K, newValue: V, shift: Int, mutatorMarker: Marker?): Array<Any?> {
         val storedKey = keyAtIndex(keyIndex)
-        val storedKeyHash = storedKey?.hashCode() ?: NULL_HASH_CODE
+        val storedKeyHash = storedKey.hashCode()
         val storedValue = valueAtKeyIndex(keyIndex)
         val newNode = makeNode(storedKeyHash, storedKey, storedValue,
                 newKeyHash, newKey, newValue, shift + LOG_MAX_BRANCHING_FACTOR, mutatorMarker)
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSet.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSet.kt
@@ -22,13 +22,11 @@ import kotlinx.collections.immutable.mutate
 internal class PersistentHashSet<E>(internal val node: TrieNode<E>,
                                     override val size: Int): AbstractSet<E>(), PersistentSet<E> {
     override fun contains(element: E): Boolean {
-        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
-        return node.contains(hashCode, element, 0)
+        return node.contains(element.hashCode(), element, 0)
     }
 
     override fun add(element: E): PersistentSet<E> {
-        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
-        val newNode = node.add(hashCode, element, 0)
+        val newNode = node.add(element.hashCode(), element, 0)
         if (node === newNode) { return this }
         return PersistentHashSet(newNode, size + 1)
     }
@@ -38,8 +36,7 @@ internal class PersistentHashSet<E>(internal val node: TrieNode<E>,
     }
 
     override fun remove(element: E): PersistentSet<E> {
-        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
-        val newNode = node.remove(hashCode, element, 0)
+        val newNode = node.remove(element.hashCode(), element, 0)
         if (node === newNode) { return this }
         if (newNode == null) { return PersistentHashSet.emptyOf() }
         return PersistentHashSet(newNode, size - 1)
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetBuilder.kt
@@ -36,21 +36,18 @@ internal class PersistentHashSetBuilder<E>(private var set: PersistentHashSet<E>
     }
 
     override fun contains(element: E): Boolean {
-        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
-        return node.contains(hashCode, element, 0)
+        return node.contains(element.hashCode(), element, 0)
     }
 
     override fun add(element: E): Boolean {
         val size = this.size
-        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
-        node = node.mutableAdd(hashCode, element, 0, this)
+        node = node.mutableAdd(element.hashCode(), element, 0, this)
         return size != this.size
     }
 
     override fun remove(element: E): Boolean {
         val size = this.size
-        val hashCode = element?.hashCode() ?: NULL_HASH_CODE
-        node = node.mutableRemove(hashCode, element, 0, this) ?: TrieNode.EMPTY as TrieNode<E>
+        node = node.mutableRemove(element.hashCode(), element, 0, this) ?: TrieNode.EMPTY as TrieNode<E>
         return size != this.size
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetMutableIterator.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetMutableIterator.kt
@@ -36,7 +36,7 @@ internal class PersistentHashSetMutableIterator<E>(private val builder: Persiste
             val currentElement = currentElement()
 
             assert(builder.remove(lastReturned))
-            resetPath(currentElement?.hashCode() ?: NULL_HASH_CODE, builder.node, currentElement, 0)
+            resetPath(currentElement.hashCode(), builder.node, currentElement, 0)
         } else {
             assert(builder.remove(lastReturned))
         }
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/TrieNode.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/TrieNode.kt
@@ -22,7 +22,6 @@ internal const val LOG_MAX_BRANCHING_FACTOR = 5
 internal const val MAX_BRANCHING_FACTOR_MINUS_ONE = MAX_BRANCHING_FACTOR - 1
 internal const val ENTRY_SIZE = 2
 internal const val MAX_SHIFT = 30
-internal const val NULL_HASH_CODE = 0
 
 
 internal class TrieNode<E>(var bitmap: Int,
@@ -99,8 +98,7 @@ internal class TrieNode<E>(var bitmap: Int,
     private fun makeNodeAtIndex(elementIndex: Int, newElementHash: Int, newElement: E,
                                 shift: Int, mutatorMarker: Marker?): TrieNode<E> {
         val storedElement = elementAtIndex(elementIndex)
-        val storedElementHash = storedElement?.hashCode() ?: NULL_HASH_CODE
-        return makeNode(storedElementHash, storedElement,
+        return makeNode(storedElement.hashCode(), storedElement,
                 newElementHash, newElement, shift + LOG_MAX_BRANCHING_FACTOR, mutatorMarker)
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSet.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSet.kt
@@ -92,7 +92,7 @@ internal class PersistentOrderedSet<E>(internal val firstElement: E?,
     }
 
     internal companion object {
-        private val EMPTY = PersistentOrderedSet(null, null, PersistentHashMap.emptyOf())
+        private val EMPTY = PersistentOrderedSet<Nothing>(null, null, PersistentHashMap.emptyOf<Nothing, Links<Nothing>>())
         internal fun <E> emptyOf(): PersistentSet<E> = EMPTY
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -52,33 +52,28 @@ internal class PersistentHashMapBuilder<K, V>(private var map: PersistentHashMap`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`override fun containsKey(key: K): Boolean {`
`55`		`- val keyHash = key?.hashCode() ?: NULL_HASH_CODE`
`56`		`- return node.containsKey(keyHash, key, 0)`
	`55`	`+ return node.containsKey(key.hashCode(), key, 0)`
`57`	`56`	`}`
`58`	`57`
`59`	`58`	`override fun get(key: K): V? {`
`60`		`- val keyHash = key?.hashCode() ?: NULL_HASH_CODE`
`61`		`- return node.get(keyHash, key, 0)`
	`59`	`+ return node.get(key.hashCode(), key, 0)`
`62`	`60`	`}`
`63`	`61`
`64`	`62`	`override fun put(key: K, value: @UnsafeVariance V): V? {`
`65`	`63`	`operationResult = null`
`66`		`- val keyHash = key?.hashCode() ?: NULL_HASH_CODE`
`67`		`- node = node.mutablePut(keyHash, key, value, 0, this)`
	`64`	`+ node = node.mutablePut(key.hashCode(), key, value, 0, this)`
`68`	`65`	`return operationResult`
`69`	`66`	`}`
`70`	`67`
`71`	`68`	`override fun remove(key: K): V? {`
`72`	`69`	`operationResult = null`
`73`		`- val keyHash = key?.hashCode() ?: NULL_HASH_CODE`
`74`		`- node = node.mutableRemove(keyHash, key, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>`
	`70`	`+ node = node.mutableRemove(key.hashCode(), key, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>`
`75`	`71`	`return operationResult`
`76`	`72`	`}`
`77`	`73`
`78`	`74`	`fun remove(key: K, value: V): Boolean {`
`79`	`75`	`val oldSize = size`
`80`		`- val keyHash = key?.hashCode() ?: NULL_HASH_CODE`
`81`		`- node = node.mutableRemove(keyHash, key, value, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>`
	`76`	`+ node = node.mutableRemove(key.hashCode(), key, value, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>`
`82`	`77`	`return oldSize != size`
`83`	`78`	`}`
`84`	`79`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ internal abstract class PersistentHashMapBuilderBaseIterator<K, V, T>(private va`
`60`	`60`	`val currentKey = currentKey()`
`61`	`61`
`62`	`62`	`builder.remove(lastKey)`
`63`		`- resetPath(currentKey?.hashCode() ?: NULL_HASH_CODE, builder.node, currentKey, 0)`
	`63`	`+ resetPath(currentKey.hashCode(), builder.node, currentKey, 0)`
`64`	`64`	`} else {`
`65`	`65`	`builder.remove(lastKey)`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,21 +36,18 @@ internal class PersistentHashSetBuilder<E>(private var set: PersistentHashSet<E>`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`override fun contains(element: E): Boolean {`
`39`		`- val hashCode = element?.hashCode() ?: NULL_HASH_CODE`
`40`		`- return node.contains(hashCode, element, 0)`
	`39`	`+ return node.contains(element.hashCode(), element, 0)`
`41`	`40`	`}`
`42`	`41`
`43`	`42`	`override fun add(element: E): Boolean {`
`44`	`43`	`val size = this.size`
`45`		`- val hashCode = element?.hashCode() ?: NULL_HASH_CODE`
`46`		`- node = node.mutableAdd(hashCode, element, 0, this)`
	`44`	`+ node = node.mutableAdd(element.hashCode(), element, 0, this)`
`47`	`45`	`return size != this.size`
`48`	`46`	`}`
`49`	`47`
`50`	`48`	`override fun remove(element: E): Boolean {`
`51`	`49`	`val size = this.size`
`52`		`- val hashCode = element?.hashCode() ?: NULL_HASH_CODE`
`53`		`- node = node.mutableRemove(hashCode, element, 0, this) ?: TrieNode.EMPTY as TrieNode<E>`
	`50`	`+ node = node.mutableRemove(element.hashCode(), element, 0, this) ?: TrieNode.EMPTY as TrieNode<E>`
`54`	`51`	`return size != this.size`
`55`	`52`	`}`
`56`	`53`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ internal class PersistentHashSetMutableIterator<E>(private val builder: Persiste`
`36`	`36`	`val currentElement = currentElement()`
`37`	`37`
`38`	`38`	`assert(builder.remove(lastReturned))`
`39`		`- resetPath(currentElement?.hashCode() ?: NULL_HASH_CODE, builder.node, currentElement, 0)`
	`39`	`+ resetPath(currentElement.hashCode(), builder.node, currentElement, 0)`
`40`	`40`	`} else {`
`41`	`41`	`assert(builder.remove(lastReturned))`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ internal class PersistentOrderedSet<E>(internal val firstElement: E?,`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`internal companion object {`
`95`		`- private val EMPTY = PersistentOrderedSet(null, null, PersistentHashMap.emptyOf())`
	`95`	`+ private val EMPTY = PersistentOrderedSet<Nothing>(null, null, PersistentHashMap.emptyOf<Nothing, Links<Nothing>>())`
`96`	`96`	`internal fun <E> emptyOf(): PersistentSet<E> = EMPTY`
`97`	`97`	`}`
`98`	`98`	`}`