Change toPersistentMap/Set to return ordered persistent set/map

Author: Abduqodiri Qurbonzoda

core/commonMain/src/extensions.kt

@@ -13,7 +13,9 @@ import kotlinx.collections.immutable.implementations.immutableMap.PersistentHash
 import kotlinx.collections.immutable.implementations.immutableSet.PersistentHashSet
 import kotlinx.collections.immutable.implementations.immutableSet.PersistentHashSetBuilder
 import kotlinx.collections.immutable.implementations.persistentOrderedMap.PersistentOrderedMap
+import kotlinx.collections.immutable.implementations.persistentOrderedMap.PersistentOrderedMapBuilder
 import kotlinx.collections.immutable.implementations.persistentOrderedSet.PersistentOrderedSet
+import kotlinx.collections.immutable.implementations.persistentOrderedSet.PersistentOrderedSetBuilder
 
 //@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 //inline fun <T> @kotlin.internal.Exact ImmutableCollection<T>.mutate(mutator: (MutableCollection<T>) -> Unit): ImmutableCollection<T> = builder().apply(mutator).build()
@@ -593,9 +595,9 @@ fun <T> Iterable<T>.toImmutableSet(): ImmutableSet<T> =
  * Elements of the returned set are iterated in the same order as in this collection
  */
 fun <T> Iterable<T>.toPersistentSet(): PersistentSet<T> =
-        this as? PersistentSet<T>
-        ?: (this as? PersistentSet.Builder)?.build()
-        ?: persistentSetOf<T>() + this
+        this as? PersistentOrderedSet<T>
+        ?: (this as? PersistentOrderedSetBuilder)?.build()
+        ?: PersistentOrderedSet.emptyOf<T>() + this
 
 /**
  * Returns a persistent set containing all elements from this set.
@@ -621,7 +623,7 @@ fun <T> Set<T>.toPersistentHashSet(): PersistentSet<T>
 fun <K, V> Map<K, V>.toImmutableMap(): ImmutableMap<K, V>
     = this as? ImmutableMap
         ?: (this as? PersistentMap.Builder)?.build()
-        ?: PersistentOrderedMap.emptyOf<K, V>().putAll(this)
+        ?: persistentMapOf<K, V>().putAll(this)
 
 /**
  * Returns a persistent map containing all entries from this map.
@@ -632,8 +634,8 @@ fun <K, V> Map<K, V>.toImmutableMap(): ImmutableMap<K, V>
  * Entries of the returned map are iterated in the same order as in this map.
  */
 fun <K, V> Map<K, V>.toPersistentMap(): PersistentMap<K, V>
-    = this as? PersistentMap<K, V>
-        ?: (this as? PersistentMap.Builder<K, V>)?.build()
+    = this as? PersistentOrderedMap<K, V>
+        ?: (this as? PersistentOrderedMapBuilder<K, V>)?.build()
         ?: PersistentOrderedMap.emptyOf<K, V>().putAll(this)
 
 /**
@@ -645,6 +647,6 @@ fun <K, V> Map<K, V>.toPersistentMap(): PersistentMap<K, V>
  * Order of the entries in the returned map is unspecified.
  */
 fun <K, V> Map<K, V>.toPersistentHashMap(): PersistentMap<K, V>
-        = this as? PersistentMap
+        = this as? PersistentHashMap
         ?: (this as? PersistentHashMapBuilder<K, V>)?.build()
         ?: PersistentHashMap.emptyOf<K, V>().putAll(this)

core/commonTest/src/contract/map/ImmutableMapTest.kt

@@ -14,10 +14,16 @@ import kotlin.test.*
 
 class ImmutableHashMapTest : ImmutableMapTest() {
     override fun <K, V> immutableMapOf(vararg pairs: Pair<K, V>): PersistentMap<K, V> = persistentHashMapOf(*pairs)
+    override fun <K, V> testBuilderToPersistentMap(builder: PersistentMap.Builder<K, V>) {
+        assertNotSame(builder.build(), builder.toPersistentMap(), "toPersistent shouldn't call build()")
+    }
 }
 class ImmutableOrderedMapTest : ImmutableMapTest() {
     override fun <K, V> immutableMapOf(vararg pairs: Pair<K, V>): PersistentMap<K, V> = persistentMapOf(*pairs)
     override fun <K, V> compareMaps(expected: Map<K, V>, actual: Map<K, V>) = compare(expected, actual) { mapBehavior(ordered = true) }
+    override fun <K, V> testBuilderToPersistentMap(builder: PersistentMap.Builder<K, V>) {
+        assertSame(builder.build(), builder.toPersistentMap(), "toPersistent should call build()")
+    }
 
     @Test fun iterationOrder() {
         var map = immutableMapOf("x" to null, "y" to 1).toPersistentMap()
@@ -35,8 +41,8 @@ class ImmutableOrderedMapTest : ImmutableMapTest() {
 }
 
 abstract class ImmutableMapTest {
-
     abstract fun <K, V> immutableMapOf(vararg pairs: Pair<K, V>): PersistentMap<K, V>
+    abstract fun <K, V> testBuilderToPersistentMap(builder: PersistentMap.Builder<K, V>)
 
     open fun <K, V> compareMaps(expected: Map<K, V>, actual: Map<K, V>) = compareMapsUnordered(expected, actual)
     fun <K, V> compareMapsUnordered(expected: Map<K, V>, actual: Map<K, V>) = compare(expected, actual) { mapBehavior(ordered = false) }
@@ -154,6 +160,8 @@ abstract class ImmutableMapTest {
         val map2 = builder.toImmutableMap()
         assertSame(map2, map, "toImmutable calls build()")
 
+        testBuilderToPersistentMap(builder)
+
         with(map) {
             testMutation { put('K', null) }
             testMutation { putAll("kotlin".associate { it to 0 }) }

core/commonTest/src/contract/set/ImmutableSetTest.kt

@@ -14,15 +14,22 @@ import kotlin.test.*
 
 class ImmutableHashSetTest : ImmutableSetTestBase() {
     override fun <T> immutableSetOf(vararg elements: T) = persistentHashSetOf(*elements)
+    override fun <T> testBuilderToPersistentSet(builder: PersistentSet.Builder<T>) {
+        assertNotSame(builder.build(), builder.toPersistentSet(), "toPersistent shouldn't call build()")
+    }
 }
 class ImmutableOrderedSetTest : ImmutableSetTestBase() {
     override fun <T> immutableSetOf(vararg elements: T) = persistentSetOf(*elements)
     override fun <T> compareSets(expected: Set<T>, actual: Set<T>) = compare(expected, actual) { setBehavior(ordered = true) }
+    override fun <T> testBuilderToPersistentSet(builder: PersistentSet.Builder<T>) {
+        assertSame(builder.build(), builder.toPersistentSet(), "toPersistent should call build()")
+    }
 }
 
 abstract class ImmutableSetTestBase {
-
     abstract fun <T> immutableSetOf(vararg elements: T): PersistentSet<T>
+    abstract fun <T> testBuilderToPersistentSet(builder: PersistentSet.Builder<T>)
+
     fun <T> immutableSetOf(elements: Collection<T>) = immutableSetOf<T>() + elements
 
     open fun <T> compareSets(expected: Set<T>, actual: Set<T>) = compareSetsUnordered(expected, actual)
@@ -103,8 +110,8 @@ abstract class ImmutableSetTestBase {
 
         val set2 = builder.toImmutableSet()
         assertTrue(set2 === set, "toImmutable calls build()")
-        val set3 = builder.toPersistentSet()
-        assertTrue(set3 === set, "toPersistent calls build()")
+
+        testBuilderToPersistentSet(builder)
 
         with(set) {
             testMutation { add('K') }