Suppress unchecked casts where appropriate

ilya-g · ilya-g · commit 782d8662b6c1 · 2019-05-03T06:42:00.000+03:00
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVector.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVector.kt
@@ -82,6 +82,7 @@ internal class PersistentVector<E>(private val root: Array<Any?>,
             newRootNode[bufferIndex] = tail
             // don't delve into the leaf level
         } else {
+            @Suppress("UNCHECKED_CAST")
             newRootNode[bufferIndex] = pushTail(newRootNode[bufferIndex] as Array<Any?>?, shift - LOG_MAX_BUFFER_SIZE, tail)
         }
         return newRootNode
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVectorBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVectorBuilder.kt
@@ -162,6 +162,7 @@ class PersistentVectorBuilder<E>(private var vector: PersistentList<E>,
 
         val elementCarry = ObjectRef(null)
         val newRest = insertIntoRoot(root!!, rootShift, index, element, elementCarry)
+        @Suppress("UNCHECKED_CAST")
         insertIntoTail(newRest, 0, elementCarry.value as E)
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVectorMutableIterator.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/PersistentVectorMutableIterator.kt
@@ -55,8 +55,10 @@ internal class PersistentVectorMutableIterator<T>(
 
         lastIteratedIndex = index - 1
 
+        @Suppress("UNCHECKED_CAST")
         val trieIterator = this.trieIterator ?: return builder.tail[--index] as T
         if (index > trieIterator.size) {
+            @Suppress("UNCHECKED_CAST")
             return builder.tail[--index - trieIterator.size] as T
         }
         index--
@@ -69,11 +71,13 @@ internal class PersistentVectorMutableIterator<T>(
 
         lastIteratedIndex = index
 
+        @Suppress("UNCHECKED_CAST")
         val trieIterator = this.trieIterator ?: return builder.tail[index++] as T
         if (trieIterator.hasNext()) {
             index++
             return trieIterator.next()
         }
+        @Suppress("UNCHECKED_CAST")
         return builder.tail[index++ - trieIterator.size] as T
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/SmallPersistentVector.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/SmallPersistentVector.kt
@@ -62,6 +62,7 @@ internal class SmallPersistentVector<E>(private val buffer: Array<Any?>) : Immut
         val newBuffer = buffer.copyOf()
         var newSize = 0
         for (element in buffer) {
+            @Suppress("UNCHECKED_CAST")
             if (!predicate(element as E)) {
                 newBuffer[newSize++] = element
             }
@@ -134,12 +135,14 @@ internal class SmallPersistentVector<E>(private val buffer: Array<Any?>) : Immut
 
     override fun listIterator(index: Int): ListIterator<E> {
         checkPositionIndex(index, size)
+        @Suppress("UNCHECKED_CAST")
         return BufferIterator(buffer as Array<E>, index, size)
     }
 
     override fun get(index: Int): E {
         // TODO: use elementAt(index)?
         checkElementIndex(index, size)
+        @Suppress("UNCHECKED_CAST")
         return buffer[index] as E
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/TrieIterator.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableList/TrieIterator.kt
@@ -43,6 +43,7 @@ internal class TrieIterator<out E>(root: Array<Any?>,
         var shift = (height - startLevel) * LOG_MAX_BUFFER_SIZE
         var i = startLevel
         while (i < height) {
+            @Suppress("UNCHECKED_CAST")
             path[i] = (path[i - 1] as Array<Any?>)[indexSegment(index, shift)]
             shift -= LOG_MAX_BUFFER_SIZE
             i += 1
@@ -64,6 +65,7 @@ internal class TrieIterator<out E>(root: Array<Any?>,
 
     private fun elementAtCurrentIndex(): E {
         val leafBufferIndex = index and MAX_BUFFER_SIZE_MINUS_ONE
+        @Suppress("UNCHECKED_CAST")
         return (path[height - 1] as Array<E>)[leafBufferIndex]
     }
 
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
@@ -74,17 +74,20 @@ internal class PersistentHashMapBuilder<K, V>(private var map: PersistentHashMap
 
     override fun remove(key: K): V? {
         operationResult = null
+        @Suppress("UNCHECKED_CAST")
         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
+        @Suppress("UNCHECKED_CAST")
         node = node.mutableRemove(key.hashCode(), key, value, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>
         return oldSize != size
     }
 
     override fun clear() {
+        @Suppress("UNCHECKED_CAST")
         node = TrieNode.EMPTY as TrieNode<K, V>
         size = 0
     }
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
@@ -23,6 +23,7 @@ internal class TrieNodeMutableEntriesIterator<K, V>(private val builder: Persist
     override fun next(): MutableMap.MutableEntry<K, V> {
         assert(hasNextKey())
         index += 2
+        @Suppress("UNCHECKED_CAST")
         return MutableMapEntry(builder, buffer[index - 2] as K, buffer[index - 1] as V)
     }
 }
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapContentIterators.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableMap/PersistentHashMapContentIterators.kt
@@ -24,6 +24,7 @@ internal abstract class TrieNodeBaseIterator<out K, out V, out T> : Iterator<T>
 
     fun currentKey(): K {
         assert(hasNextKey())
+        @Suppress("UNCHECKED_CAST")
         return buffer[index] as K
     }
 
@@ -39,6 +40,7 @@ internal abstract class TrieNodeBaseIterator<out K, out V, out T> : Iterator<T>
 
     fun currentNode(): TrieNode<out K, out V> {
         assert(hasNextNode())
+        @Suppress("UNCHECKED_CAST")
         return buffer[index] as TrieNode<K, V>
     }
 
@@ -56,6 +58,7 @@ internal class TrieNodeKeysIterator<out K, out V> : TrieNodeBaseIterator<K, V, K
     override fun next(): K {
         assert(hasNextKey())
         index += 2
+        @Suppress("UNCHECKED_CAST")
         return buffer[index - 2] as K
     }
 }
@@ -64,6 +67,7 @@ internal class TrieNodeValuesIterator<out K, out V> : TrieNodeBaseIterator<K, V,
     override fun next(): V {
         assert(hasNextKey())
         index += 2
+        @Suppress("UNCHECKED_CAST")
         return buffer[index - 1] as V
     }
 }
@@ -72,6 +76,7 @@ internal class TrieNodeEntriesIterator<out K, out V> : TrieNodeBaseIterator<K, V
     override fun next(): Map.Entry<K, V> {
         assert(hasNextKey())
         index += 2
+        @Suppress("UNCHECKED_CAST")
         return MapEntry(buffer[index - 2] as K, buffer[index - 1] as V)
     }
 }
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
@@ -63,7 +63,7 @@ internal class PersistentHashSet<E>(internal val node: TrieNode<E>,
     }
 
     internal companion object {
-        private val EMPTY = PersistentHashSet(TrieNode.EMPTY, 0)
+        private val EMPTY = PersistentHashSet<Nothing>(TrieNode.EMPTY, 0)
         internal fun <E> emptyOf(): PersistentSet<E> = PersistentHashSet.EMPTY
     }
 }
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
@@ -54,11 +54,13 @@ internal class PersistentHashSetBuilder<E>(private var set: PersistentHashSet<E>
 
     override fun remove(element: E): Boolean {
         val size = this.size
+        @Suppress("UNCHECKED_CAST")
         node = node.mutableRemove(element.hashCode(), element, 0, this) ?: TrieNode.EMPTY as TrieNode<E>
         return size != this.size
     }
 
     override fun clear() {
+        @Suppress("UNCHECKED_CAST")
         node = TrieNode.EMPTY as TrieNode<E>
         size = 0
     }
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetIterator.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/immutableSet/PersistentHashSetIterator.kt
@@ -108,11 +108,13 @@ internal class TrieNodeIterator<out E> {
 
     fun currentElement(): E {
         assert(hasNextElement())
+        @Suppress("UNCHECKED_CAST")
         return buffer[index] as E
     }
 
     fun nextElement(): E {
         assert(hasNextElement())
+        @Suppress("UNCHECKED_CAST")
         return buffer[index++] as E
     }
 
@@ -122,6 +124,7 @@ internal class TrieNodeIterator<out E> {
 
     fun currentNode(): TrieNode<out E> {
         assert(hasNextNode())
+        @Suppress("UNCHECKED_CAST")
         return buffer[index] as TrieNode<E>
     }
 }
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapBuilderContentIterators.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedMap/PersistentOrderedMapBuilderContentIterators.kt
@@ -77,6 +77,7 @@ internal class PersistentOrderedMapBuilderEntriesIterator<K, V>(map: PersistentO
 
     override fun next(): MutableMap.MutableEntry<K, V> {
         val links = internal.next()
+        @Suppress("UNCHECKED_CAST")
         return MutableMapEntry(internal.builder.hashMapBuilder, internal.lastIteratedKey as K, links)
     }
 
@@ -108,6 +109,7 @@ internal class PersistentOrderedMapBuilderKeysIterator<out K, out V>(map: Persis
 
     override fun next(): K {
         internal.next()
+        @Suppress("UNCHECKED_CAST")
         return internal.lastIteratedKey as K
     }
 
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSetBuilder.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSetBuilder.kt
@@ -55,7 +55,8 @@ internal class PersistentOrderedSetBuilder<E>(private var set: PersistentOrdered
         }
 
         val lastLinks = hashMapBuilder[lastElement]!!
-//        assert(lastLinks.next === EndOfLink)
+//        assert(!lastLinks.hasNext)
+        @Suppress("UNCHECKED_CAST")
         hashMapBuilder[lastElement as E] = lastLinks.withNext(element)
         hashMapBuilder[element] = Links(previous = lastElement)
         lastElement = element
diff --git a/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSetIterator.kt b/kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/implementations/persistentOrderedSet/PersistentOrderedSetIterator.kt
@@ -27,6 +27,7 @@ internal open class PersistentOrderedSetIterator<E>(private var nextElement: Any
     override fun next(): E {
         checkHasNext()
 
+        @Suppress("UNCHECKED_CAST")
         val result = nextElement as E
         index++
         nextElement = map[result]!!.next

Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,7 @@ internal class PersistentVector<E>(private val root: Array<Any?>,`
`82`	`82`	`newRootNode[bufferIndex] = tail`
`83`	`83`	`// don't delve into the leaf level`
`84`	`84`	`} else {`
	`85`	`+ @Suppress("UNCHECKED_CAST")`
`85`	`86`	`newRootNode[bufferIndex] = pushTail(newRootNode[bufferIndex] as Array<Any?>?, shift - LOG_MAX_BUFFER_SIZE, tail)`
`86`	`87`	`}`
`87`	`88`	`return newRootNode`
Original file line number	Diff line number	Diff line change
`@@ -162,6 +162,7 @@ class PersistentVectorBuilder<E>(private var vector: PersistentList<E>,`
`162`	`162`
`163`	`163`	`val elementCarry = ObjectRef(null)`
`164`	`164`	`val newRest = insertIntoRoot(root!!, rootShift, index, element, elementCarry)`
	`165`	`+ @Suppress("UNCHECKED_CAST")`
`165`	`166`	`insertIntoTail(newRest, 0, elementCarry.value as E)`
`166`	`167`	`}`
`167`	`168`
Original file line number	Diff line number	Diff line change
`@@ -55,8 +55,10 @@ internal class PersistentVectorMutableIterator<T>(`
`55`	`55`
`56`	`56`	`lastIteratedIndex = index - 1`
`57`	`57`
	`58`	`+ @Suppress("UNCHECKED_CAST")`
`58`	`59`	`val trieIterator = this.trieIterator ?: return builder.tail[--index] as T`
`59`	`60`	`if (index > trieIterator.size) {`
	`61`	`+ @Suppress("UNCHECKED_CAST")`
`60`	`62`	`return builder.tail[--index - trieIterator.size] as T`
`61`	`63`	`}`
`62`	`64`	`index--`
`@@ -69,11 +71,13 @@ internal class PersistentVectorMutableIterator<T>(`
`69`	`71`
`70`	`72`	`lastIteratedIndex = index`
`71`	`73`
	`74`	`+ @Suppress("UNCHECKED_CAST")`
`72`	`75`	`val trieIterator = this.trieIterator ?: return builder.tail[index++] as T`
`73`	`76`	`if (trieIterator.hasNext()) {`
`74`	`77`	`index++`
`75`	`78`	`return trieIterator.next()`
`76`	`79`	`}`
	`80`	`+ @Suppress("UNCHECKED_CAST")`
`77`	`81`	`return builder.tail[index++ - trieIterator.size] as T`
`78`	`82`	`}`
`79`	`83`
Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,7 @@ internal class SmallPersistentVector<E>(private val buffer: Array<Any?>) : Immut`
`62`	`62`	`val newBuffer = buffer.copyOf()`
`63`	`63`	`var newSize = 0`
`64`	`64`	`for (element in buffer) {`
	`65`	`+ @Suppress("UNCHECKED_CAST")`
`65`	`66`	`if (!predicate(element as E)) {`
`66`	`67`	`newBuffer[newSize++] = element`
`67`	`68`	`}`
`@@ -134,12 +135,14 @@ internal class SmallPersistentVector<E>(private val buffer: Array<Any?>) : Immut`
`134`	`135`
`135`	`136`	`override fun listIterator(index: Int): ListIterator<E> {`
`136`	`137`	`checkPositionIndex(index, size)`
	`138`	`+ @Suppress("UNCHECKED_CAST")`
`137`	`139`	`return BufferIterator(buffer as Array<E>, index, size)`
`138`	`140`	`}`
`139`	`141`
`140`	`142`	`override fun get(index: Int): E {`
`141`	`143`	`// TODO: use elementAt(index)?`
`142`	`144`	`checkElementIndex(index, size)`
	`145`	`+ @Suppress("UNCHECKED_CAST")`
`143`	`146`	`return buffer[index] as E`
`144`	`147`	`}`
`145`	`148`
Original file line number	Diff line number	Diff line change
`@@ -74,17 +74,20 @@ internal class PersistentHashMapBuilder<K, V>(private var map: PersistentHashMap`
`74`	`74`
`75`	`75`	`override fun remove(key: K): V? {`
`76`	`76`	`operationResult = null`
	`77`	`+ @Suppress("UNCHECKED_CAST")`
`77`	`78`	`node = node.mutableRemove(key.hashCode(), key, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>`
`78`	`79`	`return operationResult`
`79`	`80`	`}`
`80`	`81`
`81`	`82`	`fun remove(key: K, value: V): Boolean {`
`82`	`83`	`val oldSize = size`
	`84`	`+ @Suppress("UNCHECKED_CAST")`
`83`	`85`	`node = node.mutableRemove(key.hashCode(), key, value, 0, this) ?: TrieNode.EMPTY as TrieNode<K, V>`
`84`	`86`	`return oldSize != size`
`85`	`87`	`}`
`86`	`88`
`87`	`89`	`override fun clear() {`
	`90`	`+ @Suppress("UNCHECKED_CAST")`
`88`	`91`	`node = TrieNode.EMPTY as TrieNode<K, V>`
`89`	`92`	`size = 0`
`90`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ internal class TrieNodeMutableEntriesIterator<K, V>(private val builder: Persist`
`23`	`23`	`override fun next(): MutableMap.MutableEntry<K, V> {`
`24`	`24`	`assert(hasNextKey())`
`25`	`25`	`index += 2`
	`26`	`+ @Suppress("UNCHECKED_CAST")`
`26`	`27`	`return MutableMapEntry(builder, buffer[index - 2] as K, buffer[index - 1] as V)`
`27`	`28`	`}`
`28`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ internal abstract class TrieNodeBaseIterator<out K, out V, out T> : Iterator<T>`
`24`	`24`
`25`	`25`	`fun currentKey(): K {`
`26`	`26`	`assert(hasNextKey())`
	`27`	`+ @Suppress("UNCHECKED_CAST")`
`27`	`28`	`return buffer[index] as K`
`28`	`29`	`}`
`29`	`30`
`@@ -39,6 +40,7 @@ internal abstract class TrieNodeBaseIterator<out K, out V, out T> : Iterator<T>`
`39`	`40`
`40`	`41`	`fun currentNode(): TrieNode<out K, out V> {`
`41`	`42`	`assert(hasNextNode())`
	`43`	`+ @Suppress("UNCHECKED_CAST")`
`42`	`44`	`return buffer[index] as TrieNode<K, V>`
`43`	`45`	`}`
`44`	`46`
`@@ -56,6 +58,7 @@ internal class TrieNodeKeysIterator<out K, out V> : TrieNodeBaseIterator<K, V, K`
`56`	`58`	`override fun next(): K {`
`57`	`59`	`assert(hasNextKey())`
`58`	`60`	`index += 2`
	`61`	`+ @Suppress("UNCHECKED_CAST")`
`59`	`62`	`return buffer[index - 2] as K`
`60`	`63`	`}`
`61`	`64`	`}`
`@@ -64,6 +67,7 @@ internal class TrieNodeValuesIterator<out K, out V> : TrieNodeBaseIterator<K, V,`
`64`	`67`	`override fun next(): V {`
`65`	`68`	`assert(hasNextKey())`
`66`	`69`	`index += 2`
	`70`	`+ @Suppress("UNCHECKED_CAST")`
`67`	`71`	`return buffer[index - 1] as V`
`68`	`72`	`}`
`69`	`73`	`}`
`@@ -72,6 +76,7 @@ internal class TrieNodeEntriesIterator<out K, out V> : TrieNodeBaseIterator<K, V`
`72`	`76`	`override fun next(): Map.Entry<K, V> {`
`73`	`77`	`assert(hasNextKey())`
`74`	`78`	`index += 2`
	`79`	`+ @Suppress("UNCHECKED_CAST")`
`75`	`80`	`return MapEntry(buffer[index - 2] as K, buffer[index - 1] as V)`
`76`	`81`	`}`
`77`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ internal class PersistentHashSet<E>(internal val node: TrieNode<E>,`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`internal companion object {`
`66`		`- private val EMPTY = PersistentHashSet(TrieNode.EMPTY, 0)`
	`66`	`+ private val EMPTY = PersistentHashSet<Nothing>(TrieNode.EMPTY, 0)`
`67`	`67`	`internal fun <E> emptyOf(): PersistentSet<E> = PersistentHashSet.EMPTY`
`68`	`68`	`}`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,11 +54,13 @@ internal class PersistentHashSetBuilder<E>(private var set: PersistentHashSet<E>`
`54`	`54`
`55`	`55`	`override fun remove(element: E): Boolean {`
`56`	`56`	`val size = this.size`
	`57`	`+ @Suppress("UNCHECKED_CAST")`
`57`	`58`	`node = node.mutableRemove(element.hashCode(), element, 0, this) ?: TrieNode.EMPTY as TrieNode<E>`
`58`	`59`	`return size != this.size`
`59`	`60`	`}`
`60`	`61`
`61`	`62`	`override fun clear() {`
	`63`	`+ @Suppress("UNCHECKED_CAST")`
`62`	`64`	`node = TrieNode.EMPTY as TrieNode<E>`
`63`	`65`	`size = 0`
`64`	`66`	`}`