Rename toImmutable extensions.

Author: ilya-g

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/extensions.kt

@@ -67,23 +67,29 @@ fun <E> immutableHashSetOf(vararg elements: E): ImmutableSet<E> = ImmutableHashS
 
 fun <K, V> immutableHashMapOf(vararg pairs: Pair<K, V>): ImmutableMap<K, V> = ImmutableHashMap.emptyOf<K,V>().mutate { it += pairs }
 
-fun <T> List<T>.toImmutable(): ImmutableList<T>
-    = this as? ImmutableList
+fun <T> Iterable<T>.toImmutableList(): ImmutableList<T> =
+        this as? ImmutableList
         ?: (this as? ImmutableList.Builder)?.build()
-        ?: ImmutableVectorList.emptyOf<T>().addAll(this)
+        ?: immutableListOf<T>() + this
 
-fun <T> Set<T>.toImmutable(): ImmutableSet<T>
-    = this as? ImmutableSet<T>
+
+// fun <T> Array<T>.toImmutableList(): ImmutableList<T> = immutableListOf<T>() + this.asList()
+
+fun CharSequence.toImmutableList(): ImmutableList<Char> =
+        immutableListOf<Char>().mutate { this.toCollection(it) }
+
+fun <T> Iterable<T>.toImmutableSet(): ImmutableSet<T> =
+        this as? ImmutableSet<T>
         ?: (this as? ImmutableSet.Builder)?.build()
-        ?: ImmutableOrderedSet.emptyOf<T>().addAll(this)
+        ?: immutableSetOf<T>() + this
 
 fun <T> Set<T>.toImmutableHashSet(): ImmutableSet<T>
     = this as? ImmutableHashSet
         ?: (this as? ImmutableHashSet.Builder)?.build()
-        ?: ImmutableHashSet.emptyOf<T>().addAll(this)
+        ?: ImmutableHashSet.emptyOf<T>() + this
 
 
-fun <K, V> Map<K, V>.toImmutable(): ImmutableMap<K, V>
+fun <K, V> Map<K, V>.toImmutableMap(): ImmutableMap<K, V>
     = this as? ImmutableMap
         ?: (this as? ImmutableMap.Builder)?.build()
         ?: ImmutableHashMap.emptyOf<K, V>().putAll(this) // TODO: ImmutableOrderedMap.emptyOf

kotlinx-collections-immutable/tests/src/test/kotlin/kotlinx.collections.immutable/ImmutableListTest.kt

@@ -26,8 +26,8 @@ class ImmutableListTest {
         val original = listOf("a", "bar", "cat", null)
 
         val list = original.toMutableList() // copy
-        var immList = list.toImmutable()
-        val immList2 = immList.toImmutable()
+        var immList = list.toImmutableList()
+        val immList2 = immList.toImmutableList()
         assertTrue(immList2 === immList)
 
         assertEquals<List<*>>(list, immList) // problem
@@ -54,7 +54,7 @@ class ImmutableListTest {
     }
 
     @Test fun replaceElements() {
-        var list = "abcxaxab12".toList().toImmutable()
+        var list = "abcxaxab12".toImmutableList()
 
         for (i in list.indices) {
             list = list.set(i, list[i] as Char + i)
@@ -66,7 +66,7 @@ class ImmutableListTest {
     }
 
     @Test fun removeElements() {
-        val list = "abcxaxyz12".toList().toImmutable()
+        val list = "abcxaxyz12".toImmutableList()
         fun expectList(content: String, list: ImmutableList<Char>) {
             assertEquals(content, list.joinToString(""))
         }
@@ -83,7 +83,7 @@ class ImmutableListTest {
     }
 
     @Test fun subList() {
-        val list = "abcxaxyz12".toList().toImmutable()
+        val list = "abcxaxyz12".toImmutableList()
         val subList = list.subList(2, 5) // 2, 3, 4
         assertTrue(subList is ImmutableList)
         assertEquals(listOf('c', 'x', 'a'), subList)
@@ -99,7 +99,7 @@ class ImmutableListTest {
         assertEquals<List<*>>(list, builder)
         assertTrue(list === builder.build(), "Building the same list without modifications")
 
-        val list2 = builder.toImmutable()
+        val list2 = builder.toImmutableList()
         assertTrue(list2 === list, "toImmutable calls build()")
 
         with(list) {
@@ -132,7 +132,7 @@ class ImmutableListTest {
     @Test fun noOperation() {
         immutableListOf<Int>().testNoOperation({ clear() }, { clear() })
 
-        val list = "abcxaxyz12".toList().toImmutable()
+        val list = "abcxaxyz12".toImmutableList()
         with(list) {
             testNoOperation({ remove('d') }, { remove('d') })
             testNoOperation({ removeAll(listOf('d', 'e')) }, { removeAll(listOf('d', 'e')) })

kotlinx-collections-immutable/tests/src/test/kotlin/kotlinx.collections.immutable/ImmutableMapTest.kt

@@ -32,8 +32,8 @@ class ImmutableMapTest {
         val original = mapOf("x" to 1, "y" to null, null to 2)
 
         val map = HashMap(original) // copy
-        var immMap = map.toImmutable()
-        val immMap2 = immMap.toImmutable()
+        var immMap = map.toImmutableMap()
+        val immMap2 = immMap.toImmutableMap()
         assertTrue(immMap2 === immMap)
 
         assertEquals<Map<*, *>>(map, immMap) // problem
@@ -85,7 +85,7 @@ class ImmutableMapTest {
         assertEquals<Map<*, *>>(map, builder)
         assertTrue(map === builder.build(), "Building the same list without modifications")
 
-        val map2 = builder.toImmutable()
+        val map2 = builder.toImmutableMap()
         assertTrue(map2 === map, "toImmutable calls build()")
 
         with(map) {

kotlinx-collections-immutable/tests/src/test/kotlin/kotlinx.collections.immutable/ImmutableSetTest.kt

@@ -21,7 +21,7 @@ class ImmutableHashSetTest : ImmutableSetTestBase() {
     override fun noOperation() {
         // immutableSetOf<Int>().testNoOperation({ clear() }, { clear() })  // fails to implement this property
 
-        val list = "abcxyz12".toSet().toImmutable()
+        val list = "abcxyz12".toList().toImmutableSet()
         with(list) {
             testNoOperation({ add('a') }, { add('a') })
             testNoOperation({ addAll(listOf('a', 'b')) }, { addAll(listOf('a', 'b')) })
@@ -57,8 +57,8 @@ abstract class ImmutableSetTestBase {
         val original = setOf("a", "bar", "cat", null)
 
         val set = original.toMutableSet() // copy
-        var immSet = set.toImmutable()
-        val immSet2 = immSet.toImmutable()
+        var immSet = set.toImmutableSet()
+        val immSet2 = immSet.toImmutableSet()
         assertTrue(immSet2 === immSet)
 
         assertEquals<Set<*>>(set, immSet) // problem
@@ -84,7 +84,7 @@ abstract class ImmutableSetTestBase {
 
 
     @Test fun removeElements() {
-        val set = "abcxyz12".toSet().toImmutable()
+        val set = "abcxyz12".toList().toImmutableSet()
         fun expectSet(content: String, set: ImmutableSet<Char>) {
             assertEquals(content.toSet(), set)
         }
@@ -106,7 +106,7 @@ abstract class ImmutableSetTestBase {
         assertEquals<Set<*>>(set, builder)
         assertTrue(set === builder.build(), "Building the same set without modifications")
 
-        val set2 = builder.toImmutable()
+        val set2 = builder.toImmutableSet()
         assertTrue(set2 === set, "toImmutable calls build()")
 
         with(set) {
@@ -137,7 +137,7 @@ abstract class ImmutableSetTestBase {
     @Test open fun noOperation() {
         immutableSetOf<Int>().testNoOperation({ clear() }, { clear() })
 
-        val set = "abcxyz12".toSet().toImmutable()
+        val set = "abcxyz12".asIterable().toImmutableSet()
         with(set) {
             testNoOperation({ add('a') }, { add('a') })
             testNoOperation({ addAll(listOf('a', 'b')) }, { addAll(listOf('a', 'b')) })