Fix compilation errors in main sourceset

ilya-g · ilya-g · commit 9c9ae9a7cf5e · 2019-08-24T04:15:21.000+03:00
- provide actual for assert
- provide dummy actual for AbstractMutableList.modCount, expect for JVM,
where it is a protected field
diff --git a/core/commonMain/src/implementations/immutableList/BufferIterator.kt b/core/commonMain/src/implementations/immutableList/BufferIterator.kt
@@ -16,8 +16,6 @@
 
 package kotlinx.collections.immutable.implementations.immutableList
 
-import java.util.NoSuchElementException
-
 internal class BufferIterator<out T>(
         private val buffer: Array<T>,
         index: Int,
diff --git a/core/commonMain/src/implementations/immutableList/PersistentVector.kt b/core/commonMain/src/implementations/immutableList/PersistentVector.kt
@@ -19,6 +19,7 @@ package kotlinx.collections.immutable.implementations.immutableList
 import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.internal.ListImplementation.checkElementIndex
 import kotlinx.collections.immutable.internal.ListImplementation.checkPositionIndex
+import kotlinx.collections.immutable.internal.assert
 
 /**
  * Persistent vector made of a trie of leaf buffers entirely filled with [MAX_BUFFER_SIZE] elements and a tail having
diff --git a/core/commonMain/src/implementations/immutableList/PersistentVectorBuilder.kt b/core/commonMain/src/implementations/immutableList/PersistentVectorBuilder.kt
@@ -20,6 +20,8 @@ import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.internal.ListImplementation.checkElementIndex
 import kotlinx.collections.immutable.internal.ListImplementation.checkPositionIndex
 import kotlinx.collections.immutable.internal.MutabilityOwnership
+import kotlinx.collections.immutable.internal.assert
+import kotlinx.collections.immutable.internal.modCount
 
 class PersistentVectorBuilder<E>(private var vector: PersistentList<E>,
                                  private var vectorRoot: Array<Any?>?,
diff --git a/core/commonMain/src/implementations/immutableList/SmallPersistentVector.kt b/core/commonMain/src/implementations/immutableList/SmallPersistentVector.kt
@@ -20,6 +20,7 @@ import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.internal.ListImplementation.checkElementIndex
 import kotlinx.collections.immutable.internal.ListImplementation.checkPositionIndex
+import kotlinx.collections.immutable.internal.assert
 import kotlinx.collections.immutable.mutate
 
 internal class SmallPersistentVector<E>(private val buffer: Array<Any?>) : ImmutableList<E>, AbstractPersistentList<E>() {
diff --git a/core/commonMain/src/implementations/immutableMap/PersistentHashMapBuilderContentIterators.kt b/core/commonMain/src/implementations/immutableMap/PersistentHashMapBuilderContentIterators.kt
@@ -16,6 +16,8 @@
 
 package kotlinx.collections.immutable.implementations.immutableMap
 
+import kotlinx.collections.immutable.internal.assert
+
 
 internal class TrieNodeMutableEntriesIterator<K, V>(private val builder: PersistentHashMapBuilder<K, V>)
     : TrieNodeBaseIterator<K, V, MutableMap.MutableEntry<K, V>>() {
diff --git a/core/commonMain/src/implementations/immutableMap/PersistentHashMapContentIterators.kt b/core/commonMain/src/implementations/immutableMap/PersistentHashMapContentIterators.kt
@@ -1,5 +1,8 @@
 package kotlinx.collections.immutable.implementations.immutableMap
 
+import kotlinx.collections.immutable.internal.assert
+import kotlin.js.JsName
+
 internal const val TRIE_MAX_HEIGHT = 7
 
 internal abstract class TrieNodeBaseIterator<out K, out V, out T> : Iterator<T> {
@@ -93,6 +96,7 @@ internal open class MapEntry<out K, out V>(override val key: K, override val val
 internal abstract class PersistentHashMapBaseIterator<K, V, T>(node: TrieNode<K, V>,
                                                                protected val path: Array<TrieNodeBaseIterator<K, V, T>>) : Iterator<T> {
     private var pathLastIndex = 0
+    @JsName("_hasNext")
     private var hasNext = true
 
     init {
diff --git a/core/commonMain/src/implementations/immutableMap/TrieNode.kt b/core/commonMain/src/implementations/immutableMap/TrieNode.kt
@@ -89,7 +89,8 @@ internal class TrieNode<K, V>(
         private set
 
     /** Returns number of entries stored in this trie node (not counting subnodes) */
-    internal fun entryCount(): Int = Integer.bitCount(dataMap)
+    @UseExperimental(ExperimentalStdlibApi::class)
+    internal fun entryCount(): Int = dataMap.countOneBits()
 
     // here and later:
     // positionMask — an int in form 2^n, i.e. having the single bit set, whose ordinal is a logical position in buffer
@@ -106,13 +107,15 @@ internal class TrieNode<K, V>(
     }
 
     /** Gets the index in buffer of the data entry key corresponding to the position specified by [positionMask]. */
+    @UseExperimental(ExperimentalStdlibApi::class)
     internal fun entryKeyIndex(positionMask: Int): Int {
-        return ENTRY_SIZE * Integer.bitCount(dataMap and (positionMask - 1))
+        return ENTRY_SIZE * (dataMap and (positionMask - 1)).countOneBits()
     }
 
     /** Gets the index in buffer of the subtrie node entry corresponding to the position specified by [positionMask]. */
+    @UseExperimental(ExperimentalStdlibApi::class)
     internal fun nodeIndex(positionMask: Int): Int {
-        return buffer.size - 1 - Integer.bitCount(nodeMap and (positionMask - 1))
+        return buffer.size - 1 - (nodeMap and (positionMask - 1)).countOneBits()
     }
 
     /** Retrieves the buffer element at the given [keyIndex] as key of a data entry. */
diff --git a/core/commonMain/src/implementations/immutableSet/PersistentHashSetIterator.kt b/core/commonMain/src/implementations/immutableSet/PersistentHashSetIterator.kt
@@ -16,9 +16,13 @@
 
 package kotlinx.collections.immutable.implementations.immutableSet
 
+import kotlinx.collections.immutable.internal.assert
+import kotlin.js.JsName
+
 internal open class PersistentHashSetIterator<E>(node: TrieNode<E>) : Iterator<E> {
     protected val path = mutableListOf(TrieNodeIterator<E>())
     protected var pathLastIndex = 0
+    @JsName("_hasNext")
     private var hasNext = true
 
     init {
diff --git a/core/commonMain/src/implementations/immutableSet/PersistentHashSetMutableIterator.kt b/core/commonMain/src/implementations/immutableSet/PersistentHashSetMutableIterator.kt
@@ -16,6 +16,8 @@
 
 package kotlinx.collections.immutable.implementations.immutableSet
 
+import kotlinx.collections.immutable.internal.assert
+
 internal class PersistentHashSetMutableIterator<E>(private val builder: PersistentHashSetBuilder<E>)
     : PersistentHashSetIterator<E>(builder.node), MutableIterator<E> {
     private var lastIteratedElement: E? = null
@@ -56,7 +58,8 @@ internal class PersistentHashSetMutableIterator<E>(private val builder: Persiste
         }
 
         val position = 1 shl ((hashCode shr (pathIndex * LOG_MAX_BRANCHING_FACTOR)) and MAX_BRANCHING_FACTOR_MINUS_ONE)
-        val index = Integer.bitCount(node.bitmap and (position - 1))
+        @UseExperimental(ExperimentalStdlibApi::class)
+        val index = (node.bitmap and (position - 1)).countOneBits()
 
         path[pathIndex].reset(node.buffer, index)
 
diff --git a/core/commonMain/src/implementations/immutableSet/TrieNode.kt b/core/commonMain/src/implementations/immutableSet/TrieNode.kt
@@ -64,8 +64,9 @@ internal class TrieNode<E>(
         return bitmap and positionMask == 0
     }
 
+    @UseExperimental(ExperimentalStdlibApi::class)
     private fun indexOfCellAt(positionMask: Int): Int {
-        return Integer.bitCount(bitmap and (positionMask - 1))
+        return (bitmap and (positionMask - 1)).countOneBits()
     }
 
     private fun elementAtIndex(index: Int): E {
diff --git a/core/commonMain/src/implementations/persistentOrderedMap/PersistentOrderedMapBuilder.kt b/core/commonMain/src/implementations/persistentOrderedMap/PersistentOrderedMapBuilder.kt
@@ -18,6 +18,7 @@ package kotlinx.collections.immutable.implementations.persistentOrderedMap
 
 import kotlinx.collections.immutable.PersistentMap
 import kotlinx.collections.immutable.internal.EndOfChain
+import kotlinx.collections.immutable.internal.assert
 
 internal class PersistentOrderedMapBuilder<K, V>(private var map: PersistentOrderedMap<K, V>) : AbstractMutableMap<K, V>(), PersistentMap.Builder<K, V> {
     internal var firstKey = map.firstKey
diff --git a/core/commonMain/src/implementations/persistentOrderedSet/PersistentOrderedSetBuilder.kt b/core/commonMain/src/implementations/persistentOrderedSet/PersistentOrderedSetBuilder.kt
@@ -18,6 +18,7 @@ package kotlinx.collections.immutable.implementations.persistentOrderedSet
 
 import kotlinx.collections.immutable.PersistentSet
 import kotlinx.collections.immutable.internal.EndOfChain
+import kotlinx.collections.immutable.internal.assert
 
 internal class PersistentOrderedSetBuilder<E>(private var set: PersistentOrderedSet<E>) : AbstractMutableSet<E>(), PersistentSet.Builder<E> {
     internal var firstElement = set.firstElement
diff --git a/core/commonMain/src/internal/ListImplementation.kt b/core/commonMain/src/internal/ListImplementation.kt
@@ -16,6 +16,8 @@
 
 package kotlinx.collections.immutable.internal
 
+import kotlin.jvm.JvmStatic
+
 internal object ListImplementation {
 
     @JvmStatic
diff --git a/core/commonMain/src/internal/commonFunctions.kt b/core/commonMain/src/internal/commonFunctions.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.collections.immutable.internal
+
+internal expect fun assert(condition: Boolean)
+
+@Suppress("NO_ACTUAL_FOR_EXPECT") // implemented by protected property in JVM
+internal expect var AbstractMutableList<*>.modCount: Int
diff --git a/core/jsMain/src/internal/commonFunctions.kt b/core/jsMain/src/internal/commonFunctions.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.collections.immutable.internal
+
+internal actual fun assert(condition: Boolean) {
+    if (!condition) {
+        throw AssertionError("Assertion failed")
+    }
+}
+
+internal actual var AbstractMutableList<*>.modCount: Int
+    get() = 0
+    set(value) {}
diff --git a/core/jvmMain/src/internal/commonFunctions.kt b/core/jvmMain/src/internal/commonFunctions.kt
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.collections.immutable.internal
+
+internal actual fun assert(condition: Boolean) = kotlin.assert(condition)
diff --git a/core/nativeMain/src/internal/commonFunctions.kt b/core/nativeMain/src/internal/commonFunctions.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.collections.immutable.internal
+
+internal actual fun assert(condition: Boolean) = kotlin.assert(condition)
+
+
+internal actual var AbstractMutableList<*>.modCount: Int
+    get() = 0
+    set(value) {}

Original file line number	Diff line number	Diff line change
`@@ -64,8 +64,9 @@ internal class TrieNode<E>(`
`64`	`64`	`return bitmap and positionMask == 0`
`65`	`65`	`}`
`66`	`66`
	`67`	`+ @UseExperimental(ExperimentalStdlibApi::class)`
`67`	`68`	`private fun indexOfCellAt(positionMask: Int): Int {`
`68`		`- return Integer.bitCount(bitmap and (positionMask - 1))`
	`69`	`+ return (bitmap and (positionMask - 1)).countOneBits()`
`69`	`70`	`}`
`70`	`71`
`71`	`72`	`private fun elementAtIndex(index: Int): E {`