Adds an empty input check to all addAll, removeAll, and retainAll methods

Author: popematt

core/commonMain/src/implementations/immutableList/AbstractPersistentList.kt

@@ -8,17 +8,21 @@ package kotlinx.collections.immutable.implementations.immutableList
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.mutate
+import kotlinx.collections.immutable.internal.ListImplementation.checkPositionIndex
 
 public abstract class AbstractPersistentList<E> : PersistentList<E>, AbstractList<E>() {
     override fun subList(fromIndex: Int, toIndex: Int): ImmutableList<E> {
         return super<PersistentList>.subList(fromIndex, toIndex)
     }
 
     override fun addAll(elements: Collection<E>): PersistentList<E> {
+        if (elements.isEmpty()) return this
         return mutate { it.addAll(elements) }
     }
 
     override fun addAll(index: Int, c: Collection<E>): PersistentList<E> {
+        checkPositionIndex(index, size)
+        if (c.isEmpty()) return this
         return mutate { it.addAll(index, c) }
     }
 
@@ -31,10 +35,12 @@ public abstract class AbstractPersistentList<E> : PersistentList<E>, AbstractLis
     }
 
     override fun removeAll(elements: Collection<E>): PersistentList<E> {
+        if (elements.isEmpty()) return this
         return removeAll { elements.contains(it) }
     }
 
     override fun retainAll(elements: Collection<E>): PersistentList<E> {
+        if (elements.isEmpty()) return persistentVectorOf()
         return removeAll { !elements.contains(it) }
     }
 

core/commonMain/src/implementations/immutableList/PersistentVectorBuilder.kt

@@ -669,6 +669,7 @@ internal class PersistentVectorBuilder<E>(private var vector: PersistentList<E>,
     }
 
     override fun removeAll(elements: Collection<E>): Boolean {
+        if (elements.isEmpty()) return false
         return removeAllWithPredicate { elements.contains(it) }
     }
 

core/commonMain/src/implementations/immutableMap/PersistentHashMap.kt

@@ -68,6 +68,7 @@ internal class PersistentHashMap<K, V>(internal val node: TrieNode<K, V>,
     }
 
     override fun putAll(m: Map<out K, @UnsafeVariance V>): PersistentMap<K, V> {
+        if (m.isEmpty()) return this
         return this.mutate { it.putAll(m) }
     }
 

core/commonMain/src/implementations/immutableMap/PersistentHashMapBuilder.kt

@@ -66,6 +66,7 @@ internal class PersistentHashMapBuilder<K, V>(private var map: PersistentHashMap
     }
 
     override fun putAll(from: Map<out K, V>) {
+        if (from.isEmpty()) return
         val map = from as? PersistentHashMap ?: (from as? PersistentHashMapBuilder)?.build()
         if (map != null) @Suppress("UNCHECKED_CAST") {
             val intersectionCounter = DeltaCounter()

core/commonMain/src/implementations/immutableSet/PersistentHashSet.kt

@@ -21,6 +21,7 @@ internal class PersistentHashSet<E>(internal val node: TrieNode<E>,
     }
 
     override fun addAll(elements: Collection<E>): PersistentSet<E> {
+        if (elements.isEmpty()) return this
         return this.mutate { it.addAll(elements) }
     }
 
@@ -31,6 +32,7 @@ internal class PersistentHashSet<E>(internal val node: TrieNode<E>,
     }
 
     override fun removeAll(elements: Collection<E>): PersistentSet<E> {
+        if (elements.isEmpty()) return this
         return mutate { it.removeAll(elements) }
     }
 
@@ -39,6 +41,7 @@ internal class PersistentHashSet<E>(internal val node: TrieNode<E>,
     }
 
     override fun retainAll(elements: Collection<E>): PersistentSet<E> {
+        if (elements.isEmpty()) return PersistentHashSet.emptyOf<E>()
         return mutate { it.retainAll(elements) }
     }
 

core/commonMain/src/implementations/immutableSet/PersistentHashSetBuilder.kt

@@ -45,6 +45,7 @@ internal class PersistentHashSetBuilder<E>(private var set: PersistentHashSet<E>
     }
 
     override fun addAll(elements: Collection<E>): Boolean {
+        if (elements.isEmpty()) return false
         val set = elements as? PersistentHashSet ?: (elements as? PersistentHashSetBuilder)?.build()
         if (set !== null) {
             val deltaCounter = DeltaCounter()
@@ -81,6 +82,7 @@ internal class PersistentHashSetBuilder<E>(private var set: PersistentHashSet<E>
     }
 
     override fun removeAll(elements: Collection<E>): Boolean {
+        if (elements.isEmpty()) return false
         val set = elements as? PersistentHashSet ?: (elements as? PersistentHashSetBuilder)?.build()
         if (set !== null) {
             val counter = DeltaCounter()

core/commonMain/src/implementations/persistentOrderedMap/PersistentOrderedMap.kt

@@ -117,6 +117,7 @@ internal class PersistentOrderedMap<K, V>(
     }
 
     override fun putAll(m: Map<out K, @UnsafeVariance V>): PersistentMap<K, V> {
+        if (m.isEmpty()) return this
         return this.mutate { it.putAll(m) }
     }
 

core/commonMain/src/implementations/persistentOrderedSet/PersistentOrderedSet.kt

@@ -53,6 +53,7 @@ internal class PersistentOrderedSet<E>(
     }
 
     override fun addAll(elements: Collection<E>): PersistentSet<E> {
+        if (elements.isEmpty()) return this
         return this.mutate { it.addAll(elements) }
     }
 
@@ -78,6 +79,7 @@ internal class PersistentOrderedSet<E>(
     }
 
     override fun removeAll(elements: Collection<E>): PersistentSet<E> {
+        if (elements.isEmpty()) return this
         return mutate { it.removeAll(elements) }
     }
 
@@ -86,6 +88,7 @@ internal class PersistentOrderedSet<E>(
     }
 
     override fun retainAll(elements: Collection<E>): PersistentSet<E> {
+        if (elements.isEmpty()) return PersistentOrderedSet.emptyOf<E>()
         return mutate { it.retainAll(elements) }
     }